diff --git a/config/software/designs.json b/config/software/designs.json
index 3fd16902a0e..99d337f248a 100644
--- a/config/software/designs.json
+++ b/config/software/designs.json
@@ -939,6 +939,22 @@
"curvedSeam"
]
},
+ "umbra": {
+ "code": "Joost De Cock, Jonathan Haas",
+ "description": "A FreeSewing pattern for a basic, highly-customizable underwear pattern",
+ "design": "Joost De Cock, Jonathan Haas",
+ "difficulty": 2,
+ "lab": true,
+ "org": true,
+ "tags": [
+ "bottoms",
+ "underwear"
+ ],
+ "techniques": [
+ "elastic",
+ "curvedSeam"
+ ]
+ },
"wahid": {
"code": "Joost De Cock",
"description": "A FreeSewing pattern for a classic fitted waistcoat",
diff --git a/designs/umbra/CHANGELOG.md b/designs/umbra/CHANGELOG.md
new file mode 100644
index 00000000000..546ca0e84ad
--- /dev/null
+++ b/designs/umbra/CHANGELOG.md
@@ -0,0 +1,29 @@
+# Change log for: @freesewing/umbra
+
+
+## 3.1.0 (2023-12-26)
+
+### Fixed
+
+ - Changed defaults to have more rise in the back
+ - Increase default rise
+ - Decrease default vertical stretch
+ - Decreased default back waist dip
+ - Increased default front waist dip
+ - Allowed lower values on back exposure, causing back to flare out
+ - Fix issue with back part when bulge is on and expand is off
+
+## 3.0.0 (2023-09-30)
+
+### Changed
+
+ - All FreeSewing pacakges are now ESM only.
+ - All FreeSewing pacakges now use named exports.
+ - Dropped support for NodeJS 14. NodeJS 18 (LTS/hydrogen) or more recent is now required.
+
+
+This is the **initial release**, and the start of this change log.
+
+> Prior to version 2, FreeSewing was not a JavaScript project.
+> As such, that history is out of scope for this change log.
+
diff --git a/designs/umbra/README.md b/designs/umbra/README.md
new file mode 100644
index 00000000000..82bd51f47a5
--- /dev/null
+++ b/designs/umbra/README.md
@@ -0,0 +1,162 @@
+
+
+# @freesewing/umbra
+
+A FreeSewing pattern for a basic, highly-customizable underwear pattern
+
+
+
+# FreeSewing
+
+> [!TIP]
+>#### Support FreeSewing: Become a patron, or make a one-time donation 🥰
+>
+> FreeSewing is an open source project maintained by Joost De Cock and financially supported by the FreeSewing patrons.
+>
+> If you feel FreeSewing is worthwhile, and you can spend a few coins without
+hardship, then you should [join us and become a patron](https://freesewing.org/community/join).
+
+## What am I looking at? 🤔
+
+This repository is the FreeSewing *monorepo* holding all FreeSewing's websites, documentation, designs, plugins, and other NPM packages.
+
+This folder holds: @freesewing/umbra
+
+If you're not entirely sure what to do or how to start, type this command:
+
+```
+npm run tips
+```
+
+> [!NOTE]
+> If you don't want to set up a dev environment, you can run it in your browser:
+>
+> [](https://gitpod.io/#https://github.com/freesewing/freesewing)
+>
+> We recommend that you fork our repository and then
+> put `gitpod.io/# to start up a browser-based dev environment of your own.
+
+## About FreeSewing 💀
+
+Where the world of makers and developers collide, that's where you'll find FreeSewing.
+
+If you're a maker, checkout [freesewing.org](https://freesewing.org/) where you can generate
+sewing patterns adapted to your measurements.
+
+If you're a developer, the FreeSewing documentation lives at [freesewing.dev](https://freesewing.dev/).
+The FreeSewing [core library](https://freesewing.dev/reference/api/) is a *batteries-included* toolbox
+for parametric design of sewing patterns. But FreeSewing also provides a range
+of [plugins](https://freesewing.dev/reference/plugins/) that further extend the
+functionality of the platform.
+
+If you have NodeJS installed, you can try it right now by running:
+
+```bash
+npx @freesewing/new-design
+```
+
+Getting started guides are available for:
+- [Linux](https://freesewing.dev/tutorials/getting-started-linux/)
+- [MacOS](https://freesewing.dev/tutorials/getting-started-mac/)
+- [Windows](https://freesewing.dev/tutorials/getting-started-windows/)
+
+The [pattern design tutorial](https://freesewing.dev/tutorials/pattern-design/) will
+show you how to create your first parametric design.
+
+## Getting started ⚡
+
+To get started with FreeSewing, you can spin up our development environment with:
+
+```bash
+npx @freesewing/new-design
+```
+
+To work with FreeSewing's monorepo, you'll need [NodeJS v18](https://nodejs.org), [lerna](https://lerna.js.org/) and [yarn](https://yarnpkg.com/) on your system.
+Once you have those, clone (or fork) this repo and run `yarn kickstart`:
+
+```bash
+git clone git@github.com:freesewing/freesewing.git
+cd freesewing
+yarn kickstart
+```
+
+## Links 👩💻
+
+**Official channels**
+
+ - 💻 Makers website: [FreeSewing.org](https://freesewing.org)
+ - 💻 Developers website: [FreeSewing.dev](https://freesewing.dev)
+ - ✅ [Support](https://github.com/freesewing/freesewing/issues/new/choose),
+ [Issues](https://github.com/freesewing/freesewing/issues) &
+ [Discussions](https://github.com/freesewing/freesewing/discussions) on
+ [GitHub](https://github.com/freesewing/freesewing)
+
+**Social media**
+
+ - 🐦 Twitter: [@freesewing_org](https://twitter.com/freesewing_org)
+ - 📷 Instagram: [@freesewing_org](https://instagram.com/freesewing_org)
+
+**Places the FreeSewing community hangs out**
+
+ - 💬 [Discord](https://discord.freesewing.org/)
+ - 💬 [Facebook](https://www.facebook.com/groups/627769821272714/)
+ - 💬 [Reddit](https://www.reddit.com/r/freesewing/)
+
+## License: MIT 🤓
+
+© [Joost De Cock](https://github.com/joostdecock).
+See [the license file](https://github.com/freesewing/freesewing/blob/develop/LICENSE) for details.
+
+## Where to get help 🤯
+
+For [Support](https://github.com/freesewing/freesewing/issues/new/choose),
+please use the [Issues](https://github.com/freesewing/freesewing/issues) &
+[Discussions](https://github.com/freesewing/freesewing/discussions) on
+[GitHub](https://github.com/freesewing/freesewing).
+
diff --git a/designs/umbra/build.mjs b/designs/umbra/build.mjs
new file mode 100644
index 00000000000..99ace216bc8
--- /dev/null
+++ b/designs/umbra/build.mjs
@@ -0,0 +1,35 @@
+/* This script will build the package with esbuild */
+import esbuild from 'esbuild'
+import pkg from './package.json' assert { type: 'json' }
+
+// Create banner based on package info
+const banner = `/**
+ * ${pkg.name} | v${pkg.version}
+ * ${pkg.description}
+ * (c) ${new Date().getFullYear()} ${pkg.author}
+ * @license ${pkg.license}
+ */`
+
+// Shared esbuild options
+const options = {
+ banner: { js: banner },
+ bundle: true,
+ entryPoints: ['src/index.mjs'],
+ format: 'esm',
+ outfile: 'dist/index.mjs',
+ external: ['@freesewing'],
+ metafile: process.env.VERBOSE ? true : false,
+ minify: process.env.NO_MINIFY ? false : true,
+ sourcemap: true,
+}
+
+// Let esbuild generate the build
+const build = async () => {
+ const result = await esbuild.build(options).catch(() => process.exit(1))
+
+ if (process.env.VERBOSE) {
+ const info = await esbuild.analyzeMetafile(result.metafile)
+ console.log(info)
+ }
+}
+build()
diff --git a/designs/umbra/data.mjs b/designs/umbra/data.mjs
new file mode 100644
index 00000000000..e0312d58946
--- /dev/null
+++ b/designs/umbra/data.mjs
@@ -0,0 +1,4 @@
+// This file is auto-generated | All changes you make will be overwritten.
+export const name = '@freesewing/umbra'
+export const version = '3.2.0'
+export const data = { name, version }
diff --git a/designs/umbra/i18n/de.json b/designs/umbra/i18n/de.json
new file mode 100644
index 00000000000..264e56d9460
--- /dev/null
+++ b/designs/umbra/i18n/de.json
@@ -0,0 +1,56 @@
+{
+ "t": "Umbra, die Unterwäsche",
+ "d": "Umbra ist ein elementares, stark anpassbares Schnittmuster für Unterwäsche.",
+ "p": {
+ "back": "Rückseite",
+ "elastic": "Elastic",
+ "front": "Vorderseite",
+ "gusset": "Zwickel"
+ },
+ "s": {
+ "cutTwoPiecesOfElasticToFinishTheLegOpenings": "Schneide zwei Stücke Gummiband um die Beinöffnungen zu versäubern",
+ "cutOnePieceOfElasticToFinishTheWaistBand": "Schneide ein Stück Gummiband um das Taillenband zu versäubern"
+ },
+ "o": {
+ "fabricStretch": {
+ "t": "Stoffdehnbarkeit",
+ "d": "Passe dies für mehr oder weniger dehnbaren Stoff an"
+ },
+ "gussetWidth": {
+ "t": "Zwickelbreite",
+ "d": "Steuert die Breite des Zwickels"
+ },
+ "gussetLength": {
+ "t": "Zwickellänge",
+ "d": "Steuert die Länge des Zwickels"
+ },
+ "elasticStretch": {
+ "t": "Dehnbarkeit des Gummis",
+ "d": "Passe dies für mehr oder weniger dehnbaren Gummi an"
+ },
+ "rise": {
+ "t": "Sitz",
+ "d": "Steuert die Höhe der Taille"
+ },
+ "legOpening": {
+ "t": "Beinöffnung",
+ "d": "Legt fest, wie hoch das Bein ausgeschnitten wird"
+ },
+ "frontDip": {
+ "t": "Absenkung der vorderen Taille",
+ "d": "Steuert, wie stark die vordere Taille gekümmt ist (legt dadurch mehr oder weniger Haut frei)"
+ },
+ "backDip": {
+ "t": "Absenkung hintere Taille",
+ "d": "Steuert, wie stark die hintere Taille gekümmt ist (legt dadurch mehr oder weniger Haut frei)"
+ },
+ "taperToGusset": {
+ "t": "Vordere Freilegung",
+ "d": "Steuert die Menge an freigelegter Haut auf der vorderen Seite"
+ },
+ "backExposure": {
+ "t": "Hintere Freilegung",
+ "d": "Steuert die Menge an freigelegter Haut auf der hinteren Seite"
+ }
+ }
+}
diff --git a/designs/umbra/i18n/en.json b/designs/umbra/i18n/en.json
new file mode 100644
index 00000000000..33cf22f785c
--- /dev/null
+++ b/designs/umbra/i18n/en.json
@@ -0,0 +1,123 @@
+{
+ "t": "Umbra undies",
+ "d": "Umbra is a basic, highly-customizable underwear pattern.",
+ "p": {
+ "back": "Back",
+ "elastic": "Elastic",
+ "front": "Front",
+ "base": "Base"
+ },
+ "s": {
+ "legElasticLength.t": "You need 2x {{{ length }}} elastic to finish the legs (optional)",
+ "legElasticLength.d": "If you want to add elastic to your legs, you need two times {{{ length }}}.",
+ "legMeasure": "Leg elastic: 2x ",
+ "waistbandElasticLength.t": "You need 1x {{{ length }}} elastic to finish the waistband",
+ "waistbandElasticLength.d": "You need {{{ length }}} of elastic to finish the waistband opening.",
+ "waistbandMeasure": "Waistband elastic: ",
+ "minStretch.t": "You need fabric with a minimum stretch of {{ pct }}",
+ "minStretch.d": "Your waistband and fabric needs a minimum stretch of {{ pct }} so that you can comfortably fit through the waistband opening.",
+ "flipBackYes.t": "Flip upright",
+ "flipBackYes.d": "Flips the back part, which is constructed upside down, to an upright orientation",
+ "flipBackNo.t": "Keep upside down",
+ "flipBackNo.d": "Keeps the back part in its original orientation, which might help in the pattern inspector view",
+ "pockets.none.t": "No Pockets",
+ "pockets.none.d": "Create the design without any pockets (default)",
+ "pockets.inside.t": "Inside Pockets",
+ "pockets.inside.d": "Create two secret pockets on the insides and a center front pouch",
+ "pockets.zipper.t": "Front pockets with zippers",
+ "pockets.zipper.d": "Create two front pockets with zippers",
+ "foldLining": "Fold lining",
+ "pocketSeam": "Pocket seam",
+ "zipper": "Zipper"
+ },
+ "o": {
+ "bulge": {
+ "t": "Bulge",
+ "d": "Increase the bugle angle to create more room in the front pouch. Doesn't kick in below 2 degrees."
+ },
+ "bulgeFullness": {
+ "t": "Bulge fullness",
+ "d": "Determines the roundness of the bulge. Doesn't have an effect if the bulge is disabled."
+ },
+ "splitPosition": {
+ "t": "Crotch seam",
+ "d": "Determines the position of the crotch seam"
+ },
+ "gussetPosition": {
+ "t": "Gusset position",
+ "d": "Shift the gusset (crotch position with the smallest width) forwards or backwards. The default position equals the cross seam front measurement."
+ },
+ "gussetWidth": {
+ "t": "Gusset width",
+ "d": "Controls the minimum width in the crotch area"
+ },
+ "xStretch": {
+ "t": "Horizontal fabric stretch",
+ "d": "Adjust this for more or less stretchy fabric in the horizontal direction"
+ },
+ "yStretch": {
+ "t": "Vertical fabric stretch",
+ "d": "Adjust this for more or less stretchy fabric in the vertical direction"
+ },
+ "elasticStretch": {
+ "t": "Elastic stretch",
+ "d": "Adjust how much the elastics are stretched relative to the fabric"
+ },
+ "rise": {
+ "t": "Rise",
+ "d": "Controls the height of the waist. A value of 100% puts the waistband onto the measured hip line."
+ },
+ "legRise": {
+ "t": "Leg rise",
+ "d": "Controls how high the leg is cut out"
+ },
+ "frontDip": {
+ "t": "Front waist dip",
+ "d": "Controls how much the front waist curves (revealing more or less skin)"
+ },
+ "frontDipShape": {
+ "t": "Front waist dip shape",
+ "d": "Controls the shape of the front waist dip. Doesn't have much effect if the front waist dip is zero."
+ },
+ "backDip": {
+ "t": "Back waist dip",
+ "d": "Controls how much the back waist curves (revealing more or less skin)"
+ },
+ "backDipShape": {
+ "t": "Back waist dip shape",
+ "d": "Controls the shape of the back waist dip. Doesn't have much effect if the back waist dip is zero."
+ },
+ "frontExposure": {
+ "t": "Front exposure",
+ "d": "Controls the amount of exposed skin on the front"
+ },
+ "frontReduction": {
+ "t": "Front narrowing",
+ "d": "Controls by how much the front part is slimmer than the back part"
+ },
+ "pockets": {
+ "t": "Pockets",
+ "d": "Choose if you want pockets"
+ },
+ "pocketHeight": {
+ "t": "Pocket height",
+ "d": "Controls the position of the pocket hem or the zippers. Increasing this option results in shorter pockets. Only has an effect with pockets enabled."
+ },
+ "pocketGap": {
+ "t": "Pocket gap",
+ "d": "Controls how much space is left in the front between both pockets. Only has an effect with pockets enabled."
+ },
+ "backExposure": {
+ "t": "Back exposure",
+ "d": "Controls the amount of exposed skin on the back"
+ },
+ "minFabricWidth":{
+ "t": "Minimum fabric width",
+ "d": "Controls the minimum width of the thong strip and side band. Does not have an effect if the back exposure and the leg rise is low."
+ },
+ "flipBack": {
+ "t": "Flip back",
+ "d": "Determines if the back part should be rendered upside down"
+ }
+ }
+}
diff --git a/designs/umbra/i18n/es.json b/designs/umbra/i18n/es.json
new file mode 100644
index 00000000000..16b35cda164
--- /dev/null
+++ b/designs/umbra/i18n/es.json
@@ -0,0 +1,56 @@
+{
+ "t": "Umbra, braguitas",
+ "d": "Umbra es un patrón básico de braguitas altamente personalizable.",
+ "p": {
+ "back": "Atrás",
+ "elastic": "Elastic",
+ "front": "Frente",
+ "gusset": "Gusset"
+ },
+ "s": {
+ "cutTwoPiecesOfElasticToFinishTheLegOpenings": "Corta dos trozos de elástico para acabar la abertura de las perneras",
+ "cutOnePieceOfElasticToFinishTheWaistBand": "Corta un trozo de elástico para acabar la cintura"
+ },
+ "o": {
+ "fabricStretch": {
+ "t": "estiramiento de tela",
+ "d": "Ajustar esto para más o menos tela estirada"
+ },
+ "gussetWidth": {
+ "t": "Gusset width",
+ "d": "Controla el ancho del set de ráfaga"
+ },
+ "gussetLength": {
+ "t": "Longitud del Gusset",
+ "d": "Controla la longitud del set de ráfaga"
+ },
+ "elasticStretch": {
+ "t": "Estiramiento elástico",
+ "d": "Ajustar esto para elástico más o menos estirado"
+ },
+ "rise": {
+ "t": "Elevación de la cintura",
+ "d": "Controla la altura de la cintura"
+ },
+ "legOpening": {
+ "t": "Apertura de la pierna",
+ "d": "Controla hasta qué punto se corta la pierna"
+ },
+ "frontDip": {
+ "t": "Buceo de cintura frontal",
+ "d": "Controla cuánto son las curvas de la cintura frontal (revelando más o menos la piel)"
+ },
+ "backDip": {
+ "t": "Buceo de cintura trasera",
+ "d": "Controla cuánto son las curvas de la cintura trasera (revelando más o menos la piel)"
+ },
+ "taperToGusset": {
+ "t": "Exposición frontal",
+ "d": "Controla la cantidad de piel expuesta en la parte frontal"
+ },
+ "backExposure": {
+ "t": "Exposición trasera",
+ "d": "Controla la cantidad de piel expuesta en la espalda"
+ }
+ }
+}
diff --git a/designs/umbra/i18n/fr.json b/designs/umbra/i18n/fr.json
new file mode 100644
index 00000000000..dc5a3b5eb35
--- /dev/null
+++ b/designs/umbra/i18n/fr.json
@@ -0,0 +1,56 @@
+{
+ "t": "Unités d'Umbra",
+ "d": "Umbra est un motif basique et hautement personnalisable.",
+ "p": {
+ "back": "Retour",
+ "elastic": "Elastic",
+ "front": "Avant",
+ "gusset": "Soufflet"
+ },
+ "s": {
+ "cutTwoPiecesOfElasticToFinishTheLegOpenings": "Couper deux élastiques pour finir les ouvertures des jambes",
+ "cutOnePieceOfElasticToFinishTheWaistBand": "Couper une pièce d'élastique pour finir la bande de taille"
+ },
+ "o": {
+ "fabricStretch": {
+ "t": "Étendue en tissu",
+ "d": "Ajuster ceci pour des tissus plus ou moins extensifs"
+ },
+ "gussetWidth": {
+ "t": "Gusset width",
+ "d": "Contrôle la largeur du gusset"
+ },
+ "gussetLength": {
+ "t": "Longueur du Gusset",
+ "d": "Contrôle la longueur du gusset"
+ },
+ "elasticStretch": {
+ "t": "Etendue élastique",
+ "d": "Ajuster ceci pour un élastique plus ou moins extensif"
+ },
+ "rise": {
+ "t": "Élévation de ceinture",
+ "d": "Contrôle la hauteur de la taille"
+ },
+ "legOpening": {
+ "t": "Ouverture des jambes",
+ "d": "Contrôle la hauteur de la jambe découpée"
+ },
+ "frontDip": {
+ "t": "tremper la taille de la taille avant",
+ "d": "Contrôle la quantité de courbes de la taille avant (révélant plus ou moins la peau)"
+ },
+ "backDip": {
+ "t": "trempette à taille arrière",
+ "d": "Contrôle la quantité de courbes de la taille arrière (révélant plus ou moins la peau)"
+ },
+ "taperToGusset": {
+ "t": "Exposition frontale",
+ "d": "Contrôle la quantité de peau exposée à l'avant"
+ },
+ "backExposure": {
+ "t": "Exposition au dos",
+ "d": "Contrôle la quantité de peau exposée au dos"
+ }
+ }
+}
diff --git a/designs/umbra/i18n/index.mjs b/designs/umbra/i18n/index.mjs
new file mode 100644
index 00000000000..36aac928b67
--- /dev/null
+++ b/designs/umbra/i18n/index.mjs
@@ -0,0 +1,8 @@
+import en from './en.json' assert { type: 'json' }
+import de from './de.json' assert { type: 'json' }
+import es from './es.json' assert { type: 'json' }
+import fr from './fr.json' assert { type: 'json' }
+import nl from './nl.json' assert { type: 'json' }
+import uk from './uk.json' assert { type: 'json' }
+
+export const i18n = { en, de, es, fr, nl, uk }
diff --git a/designs/umbra/i18n/nl.json b/designs/umbra/i18n/nl.json
new file mode 100644
index 00000000000..bf706ea3331
--- /dev/null
+++ b/designs/umbra/i18n/nl.json
@@ -0,0 +1,56 @@
+{
+ "t": "Umbra undies",
+ "d": "Umbra is een fundamenteel, zeer aanpasbaar ondergoed patroon.",
+ "p": {
+ "back": "Achterzijde",
+ "elastic": "Elastic",
+ "front": "Voorzijde",
+ "gusset": "Gusset"
+ },
+ "s": {
+ "cutTwoPiecesOfElasticToFinishTheLegOpenings": "Cut two pieces of elastic to finish the leg openings",
+ "cutOnePieceOfElasticToFinishTheWaistBand": "Cut one piece of elastic to finish the waist band"
+ },
+ "o": {
+ "fabricStretch": {
+ "t": "Stof stretch",
+ "d": "Pas dit aan voor meer of minder elastische stoffen"
+ },
+ "gussetWidth": {
+ "t": "Gusset width",
+ "d": "Bepaalt de breedte van de gusset"
+ },
+ "gussetLength": {
+ "t": "Gusset lengte",
+ "d": "Bepaalt de lengte van de gusset"
+ },
+ "elasticStretch": {
+ "t": "Elastische stretch",
+ "d": "Pas dit aan voor meer of minder elastische elastiek"
+ },
+ "rise": {
+ "t": "Hoogte",
+ "d": "Bepaalt de hoogte van de taille"
+ },
+ "legOpening": {
+ "t": "Been opening",
+ "d": "Bepaalt hoe hoog de broekspijp wordt uitgeknipt"
+ },
+ "frontDip": {
+ "t": "Voorste taille dip",
+ "d": "Bepaalt hoeveel de taillecurven vooraan tonen (min of meer skin)"
+ },
+ "backDip": {
+ "t": "Achterste dip taille",
+ "d": "Bepaalt hoeveel de omgekeerde golfcurves (min of meer skin onthullen)"
+ },
+ "taperToGusset": {
+ "t": "Blootstelling voorzijde",
+ "d": "Bepaalt de hoeveelheid blootgestelde huid aan de voorkant"
+ },
+ "backExposure": {
+ "t": "Blootstelling rug",
+ "d": "Bepaalt de hoeveelheid gelekte huid aan de achterkant"
+ }
+ }
+}
diff --git a/designs/umbra/i18n/uk.json b/designs/umbra/i18n/uk.json
new file mode 100644
index 00000000000..db8921f3faf
--- /dev/null
+++ b/designs/umbra/i18n/uk.json
@@ -0,0 +1,56 @@
+{
+ "t": "Umbra undies",
+ "d": "Umbra is a basic, highly-customizable underwear pattern.",
+ "p": {
+ "back": "Back",
+ "elastic": "Elastic",
+ "front": "Front",
+ "gusset": "Gusset"
+ },
+ "s": {
+ "cutTwoPiecesOfElasticToFinishTheLegOpenings": "Cut two pieces of elastic to finish the leg openings",
+ "cutOnePieceOfElasticToFinishTheWaistBand": "Cut one piece of elastic to finish the waist band"
+ },
+ "o": {
+ "fabricStretch": {
+ "t": "Fabric stretch",
+ "d": "Adjust this for more or less stretchy fabrics"
+ },
+ "gussetWidth": {
+ "t": "Gusset width",
+ "d": "Controls the width of the gusset"
+ },
+ "gussetLength": {
+ "t": "Gusset length",
+ "d": "Controls the length of the gusset"
+ },
+ "elasticStretch": {
+ "t": "Elastic stretch",
+ "d": "Adjust this for more or less stretchy elastic"
+ },
+ "rise": {
+ "t": "Rise",
+ "d": "Controls the height of the waist"
+ },
+ "legOpening": {
+ "t": "Leg opening",
+ "d": "Controls how high the leg is cut out"
+ },
+ "frontDip": {
+ "t": "Front waist dip",
+ "d": "Controls how much the front waist curves (revealing more or less skin)"
+ },
+ "backDip": {
+ "t": "Back waist dip",
+ "d": "Controls how much the back waist curves (revealing more or less skin)"
+ },
+ "taperToGusset": {
+ "t": "Front exposure",
+ "d": "Controls the amount of exposed skin on the front"
+ },
+ "backExposure": {
+ "t": "Back exposure",
+ "d": "Controls the amount of exposed skin on the back"
+ }
+ }
+}
diff --git a/designs/umbra/package.json b/designs/umbra/package.json
new file mode 100644
index 00000000000..087c4cf56b4
--- /dev/null
+++ b/designs/umbra/package.json
@@ -0,0 +1,71 @@
+{
+ "name": "@freesewing/umbra",
+ "version": "3.2.0",
+ "description": "A FreeSewing pattern for a basic, highly-customizable underwear pattern",
+ "author": "Joost De Cock (https://github.com/joostdecock)",
+ "homepage": "https://freesewing.org/",
+ "repository": "github:freesewing/freesewing",
+ "license": "MIT",
+ "bugs": {
+ "url": "https://github.com/freesewing/freesewing/issues"
+ },
+ "funding": {
+ "type": "individual",
+ "url": "https://freesewing.org/patrons/join"
+ },
+ "keywords": [
+ "freesewing",
+ "design",
+ "diy",
+ "fashion",
+ "made to measure",
+ "parametric design",
+ "pattern",
+ "sewing",
+ "sewing pattern"
+ ],
+ "type": "module",
+ "module": "dist/index.mjs",
+ "exports": {
+ ".": {
+ "internal": "./src/index.mjs",
+ "default": "./dist/index.mjs"
+ }
+ },
+ "scripts": {
+ "build": "node build.mjs",
+ "build:all": "yarn build",
+ "clean": "rimraf dist",
+ "mbuild": "NO_MINIFY=1 node build.mjs",
+ "symlink": "mkdir -p ./node_modules/@freesewing && cd ./node_modules/@freesewing && ln -s -f ../../../* . && cd -",
+ "test": "npx mocha tests/*.test.mjs",
+ "vbuild": "VERBOSE=1 node build.mjs",
+ "lab": "cd ../../sites/lab && yarn start",
+ "tips": "node ../../scripts/help.mjs",
+ "lint": "npx eslint 'src/**' 'tests/*.mjs'",
+ "prettier": "npx prettier --write 'src/*.mjs' 'tests/*.mjs'",
+ "testci": "NODE_OPTIONS=\"--conditions=internal\" npx mocha tests/*.test.mjs --reporter ../../tests/reporters/terse.js",
+ "wbuild": "node build.mjs",
+ "wbuild:all": "yarn wbuild"
+ },
+ "peerDependencies": {
+ "@freesewing/core": "3.2.0"
+ },
+ "devDependencies": {
+ "@freesewing/models": "3.2.0",
+ "@freesewing/plugin-timing": "3.2.0",
+ "chai": "5.1.0",
+ "mocha": "10.3.0"
+ },
+ "files": [
+ "dist/*",
+ "README.md"
+ ],
+ "publishConfig": {
+ "access": "public",
+ "tag": "latest"
+ },
+ "engines": {
+ "node": ">= 18.17.0 <22"
+ }
+}
diff --git a/designs/umbra/src/back.mjs b/designs/umbra/src/back.mjs
new file mode 100644
index 00000000000..b4a76f22707
--- /dev/null
+++ b/designs/umbra/src/back.mjs
@@ -0,0 +1,233 @@
+import { base } from './base.mjs'
+
+export const back = {
+ name: 'umbra.back',
+ from: base,
+ draft: draftUmbraBack,
+}
+
+/*
+ * This drafts the back of Umbra, or rather recycles what's needed from base
+ */
+function draftUmbraBack({
+ Point,
+ Path,
+ points,
+ paths,
+ store,
+ sa,
+ Snippet,
+ snippets,
+ options,
+ expand,
+ macro,
+ part,
+}) {
+ /*
+ * We'll use this list later
+ */
+ const toFlip = [
+ 'cfWaistbandDipCp1Back',
+ 'cfWaistbandDipCp2Back',
+ 'sideWaistbandBack',
+ 'sideLegBack',
+ 'backGussetSplit',
+ ]
+
+ /*
+ * Depending on the expand setting, we'll draw a full back
+ * or one to be cut on the fold
+ */
+ if (expand) {
+ /*
+ * Expand is on, show the entire part
+ */
+
+ if (options.flipBack) {
+ /*
+ * We need the flip these points to construct the left half
+ */
+ for (const pid of toFlip) {
+ // Flip existing points along Y-axis
+ points[pid] = points[pid].flipY()
+ }
+ // Also Y-flip these central points
+ points.cfWaistbandDipBack = points.cfWaistbandDipBack.flipY()
+ points.cfBackGusset = points.cfBackGusset.flipY()
+ }
+
+ /*
+ * Draw the path
+ */
+ if (options.flipBack) {
+ macro('mirror', {
+ mirror: [new Point(0, 0), new Point(100, 0)],
+ paths: ['back'],
+ clone: true,
+ })
+ } else {
+ paths.mirroredBack = paths.back.reverse()
+ }
+ macro('mirror', {
+ mirror: [new Point(0, 0), new Point(0, 100)],
+ paths: ['mirroredBack'],
+ clone: true,
+ })
+ paths.seam = paths.mirroredBack.join(paths.mirroredMirroredBack.reverse()).addClass('fabric')
+ paths.mirroredBack.hide()
+ paths.mirroredMirroredBack.hide()
+
+ if (sa) paths.sa = paths.seam.offset(sa * -1).addClass('fabric sa')
+
+ /*
+ * Set the cutlist info
+ */
+ store.cutlist.setCut({ cut: 1, from: 'fabric' })
+
+ /*
+ * Add grainline
+ */
+ macro('grainline', {
+ from: new Point(0, points.backGussetSplit.y),
+ to: points.cfWaistbandDipBack,
+ })
+ } else {
+ if (options.flipBack) {
+ /*
+ * Expand is off, cut on fold
+ */
+ for (const pid of toFlip) {
+ // Flip existing points along Y-axis
+ points[pid] = points[pid].flipY()
+ }
+ // Also Y-flip these central points
+ points.cfWaistbandDipBack = points.cfWaistbandDipBack.flipY()
+ points.cfBackGusset = points.cfBackGusset.flipY()
+
+ macro('mirror', {
+ mirror: [new Point(0, 0), new Point(100, 0)],
+ paths: ['back'],
+ clone: true,
+ })
+ paths.mirroredBack.hide()
+ paths.saBase = paths.mirroredBack.reverse().hide()
+ } else {
+ paths.saBase = paths.back
+ }
+
+ paths.seam = paths.saBase
+ .clone()
+ .line(points.cfWaistbandDipBack)
+ .close()
+ .unhide()
+ .addClass('fabric')
+
+ if (sa) {
+ paths.sa = new Path()
+ .move(points.cfBackGusset)
+ .join(paths.saBase.offset(sa))
+ .line(paths.saBase.end())
+ .addClass('fabric sa')
+ }
+
+ /*
+ * Set the cutlist info
+ */
+ store.cutlist.setCut({ cut: 1, from: 'fabric', onFold: true })
+
+ /*
+ * Add cut on fold indicator
+ */
+ macro('cutonfold', {
+ from: points.cfWaistbandDipBack,
+ to: points.cfBackGusset,
+ grainline: true,
+ })
+ }
+
+ /*
+ * Dimensions
+ */
+ macro('hd', {
+ id: 'wAtBottom',
+ from: points.cfBackGusset,
+ to: points.backGussetSplit,
+ y: points.cfBackGusset.y + sa + 15,
+ })
+ macro('hd', {
+ id: 'wAtLeg',
+ from: points.cfBackGusset,
+ to: points.sideLegBack,
+ y: points.cfBackGusset.y + sa + 30,
+ })
+ macro('hd', {
+ id: 'wAtTop',
+ from: points.cfWaistbandDipBack,
+ to: points.sideWaistbandBack,
+ y: points.sideWaistbandBack.y - sa - 15,
+ })
+ macro('vd', {
+ id: 'hToLeg',
+ from: points.backGussetSplit,
+ to: points.sideLegBack,
+ x: points.sideLegBack.x + sa + 15,
+ })
+ macro('vd', {
+ id: 'hToCfWaistband',
+ from: points.backGussetSplit,
+ to: points.cfWaistbandDipBack,
+ x: points.sideLegBack.x + sa + 30,
+ })
+ if (options.backDip !== 0) {
+ macro('vd', {
+ id: 'hToSideWaistband',
+ from: points.backGussetSplit,
+ to: points.sideWaistbandBack,
+ x: points.sideLegBack.x + sa + 45,
+ })
+ }
+
+ let backCenter = points.sideWaistbandBack.shiftFractionTowards(points.sideLegBack, 0.5)
+ snippets.sideBackCenter = new Snippet('notch', backCenter)
+ if (expand) {
+ snippets.sideBackCenterMirrored = new Snippet('notch', new Point(-backCenter.x, backCenter.y))
+ }
+
+ /*
+ * Clean up paths from base
+ */
+ delete paths.back
+ delete paths.front
+ delete paths.gusset
+ delete paths.frontAndGusset
+ delete paths.bulge
+ delete paths.pocketHeight
+ delete paths.saBase
+ delete paths.pocketShape
+ delete paths.zipper
+ delete paths.mirroredZipper
+ delete paths.zipperCut
+
+ /*
+ * Title
+ */
+ if (options.flipBack) {
+ points.title = points.cfWaistbandDipBack.shift(0, 20).shift(-90, 50)
+ } else {
+ points.title = points.cfWaistbandDipBack.shift(0, 20).shift(90, 50)
+ }
+
+ macro('title', {
+ at: points.title,
+ nr: 2,
+ title: 'back',
+ })
+
+ /*
+ * Logo
+ */
+ points.logo = points.title.shiftFractionTowards(points.sideLegBack, 0.6).shift(-90, 20)
+ snippets.logo = new Snippet('logo', points.logo)
+
+ return part
+}
diff --git a/designs/umbra/src/base.mjs b/designs/umbra/src/base.mjs
new file mode 100644
index 00000000000..e8d443cd73a
--- /dev/null
+++ b/designs/umbra/src/base.mjs
@@ -0,0 +1,819 @@
+import { stretchToScale } from '@freesewing/core'
+
+function draftUmbraBase({
+ options,
+ Point,
+ Path,
+ points,
+ paths,
+ measurements,
+ complete,
+ store,
+ utils,
+ expand,
+ units,
+ macro,
+ part,
+}) {
+ /*
+ * Helper Functions
+ */
+ /**
+ * Interpolates between 3 given values.
+ * A factor of 0 will return `v1`, a factor of 0.5 will return `v2` and a factor of 1 will return `v3`.
+ * In between factors will interpolate linearly between the neighbouring values.
+ * Factors outside the range 0..1 are unsupported.
+ *
+ * @param v1 {number} First value
+ * @param v2 {number} Second value
+ * @param v3 {number} Third value
+ * @param factor {number} factor
+ * @return {number}
+ */
+ function interpolateValue(v1, v2, v3, factor) {
+ if (factor < 0.5) {
+ return 2 * (v2 * factor + v1 * (0.5 - factor))
+ }
+ return 2 * (v3 * (factor - 0.5) + v2 * (1 - factor))
+ }
+
+ /**
+ * Interpolates between 3 given points.
+ * A factor of 0 will return `p1`, a factor of 0.5 will return `p2` and a factor of 1 will return `p3`.
+ * In between factors will interpolate linearly between the neighbouring points.
+ *
+ * @param p1 {Point} First point
+ * @param p2 {Point} Second point
+ * @param p3 {Point} Third point
+ * @param factor {number} factor
+ * @return {Point}
+ */
+ function interpolatePoint(p1, p2, p3, factor) {
+ return new Point(
+ interpolateValue(p1.x, p2.x, p3.x, factor),
+ interpolateValue(p1.y, p2.y, p3.y, factor)
+ )
+ }
+
+ /*
+ * Calculate stretch for easy access
+ */
+ const stretch = {
+ x: utils.stretchToScale(options.xStretch),
+ y: utils.stretchToScale(options.yStretch),
+ elastic: utils.stretchToScale(options.elasticStretch),
+ }
+
+ let minFabricWidth = options.minFabricWidth * measurements.seat
+
+ /*
+ * Create points
+ * All center front (cf) points have x=0
+ * All side points have positive Y-coordinate
+ * Note that we're only drafting half of the shape as it's symmetric
+ */
+
+ /*
+ * Waist line
+ */
+ points.cfWaist = new Point(0, 0)
+ points.sideWaist = new Point((measurements.waist / 4) * stretch.x, 0)
+
+ /*
+ * Hip line
+ */
+ points.cfHips = new Point(0, measurements.waistToHips * stretch.y)
+ points.sideHips = new Point((measurements.hips / 4) * stretch.x, points.cfHips.y)
+
+ /*
+ * Seat line
+ */
+ points.cfSeat = new Point(0, measurements.waistToSeat * stretch.y)
+ points.sideSeat = new Point((measurements.seat / 4) * stretch.x, points.cfSeat.y)
+
+ /*
+ * The absolute middle, will be used to mirror the waistline to the back
+ */
+ const waistToMiddle = measurements.crossSeam / 2
+ points.cfMiddle = new Point(0, stretch.y * waistToMiddle)
+
+ /*
+ * The gusset position (slimmest part in the crotch)
+ */
+ points.cfGusset = new Point(
+ 0,
+ stretch.y *
+ interpolateValue(
+ measurements.waistToSeat,
+ measurements.crossSeamFront,
+ waistToMiddle,
+ options.gussetPosition
+ )
+ )
+ points.sideGusset = new Point(waistToMiddle * options.gussetWidth * stretch.x, points.cfGusset.y)
+
+ /*
+ * This path plots the width of the body from the waist to the seat to position the waistband according to height
+ */
+ paths.bodySide = new Path()
+ .move(points.sideWaist)
+ .line(points.sideHips)
+ .line(points.sideSeat)
+ .hide()
+
+ /*
+ * Waistband line
+ */
+ points.cfWaistband = points.cfSeat.shiftFractionTowards(points.cfHips, options.rise)
+ const intersection = paths.bodySide.intersectsY(points.cfWaistband.y)
+ if (intersection == null || intersection.length === 0) {
+ // If the waistband is somehow above the waistline, continue to use the waist measurement
+ // This is mostly to prevent errors when the user entered an abnormally low distance between waist and hips
+ // together with a very high rise
+ points.sideWaistbandBase = new Point(points.sideWaist.x, points.cfWaistband.y)
+ } else {
+ points.sideWaistbandBase = intersection[0]
+ }
+
+ /*
+ * Start of the leg opening
+ */
+ points.sideLegBase = points.sideSeat.shiftTowards(
+ points.sideWaistbandBase,
+ options.legRise * points.cfGusset.dist(points.cfHips)
+ )
+
+ // Enforce minimum fabric width above leg opening
+ if (
+ points.sideLegBase.dist(points.sideWaistbandBase) < minFabricWidth ||
+ points.sideLegBase.y < points.sideWaistbandBase.y
+ ) {
+ points.sideLegBase = points.sideWaistbandBase.shiftTowards(points.sideSeat, minFabricWidth)
+ }
+
+ /*
+ * Determine crotch seam split position
+ */
+ points.cfMaxSplit = new Point(0, 2 * stretch.y * waistToMiddle - points.sideLegBase.y)
+ points.cfBackGusset = points.cfGusset.shiftFractionTowards(
+ points.cfMaxSplit,
+ options.splitPosition
+ )
+
+ /*
+ * Now add the front gusset control point
+ */
+ points.gussetFrontCp = points.sideGusset.shift(
+ 90,
+ points.sideLegBase.dy(points.sideGusset) * options.frontExposure
+ )
+
+ /*
+ * Flip front side waistband positions to back
+ */
+ for (const flip of ['cfWaist', 'cfWaistband', 'sideWaistbandBase', 'sideLegBase']) {
+ points[`${flip}Back`] = points[flip].flipY(points.cfMiddle)
+ }
+
+ // Make the front smaller by options.frontReduction
+ points.sideWaistbandFront = new Point(
+ points.sideWaistbandBase.x * (1 - options.frontReduction),
+ points.sideWaistbandBase.y
+ )
+ points.sideLegFront = new Point(
+ points.sideLegBase.x * (1 - options.frontReduction),
+ points.sideLegBase.y
+ )
+
+ // Add the reduced distance to the back part
+ points.sideWaistbandBack = points.sideWaistbandBaseBack.shift(
+ 0,
+ points.sideWaistbandFront.dist(points.sideWaistbandBase)
+ )
+ points.sideLegBack = points.sideLegBaseBack.shift(0, points.sideLegFront.dist(points.sideLegBase))
+ // correct for different length
+ points.sideLegBack = points.sideWaistbandBack.shiftTowards(
+ points.sideLegBack,
+ points.sideWaistbandFront.dist(points.sideLegFront)
+ )
+
+ /*
+ * Dip the waistband at the front
+ */
+ points.cfWaistbandDipCp1Front = utils.beamIntersectsX(
+ points.sideWaistbandFront,
+ points.sideLegFront.rotate(-90, points.sideWaistbandFront),
+ points.sideWaistbandFront.x / 2
+ )
+ points.cfWaistbandDipFront = new Point(
+ 0,
+ points.cfWaistbandDipCp1Front.y + waistToMiddle * options.frontDip
+ )
+ points.cfWaistbandDipCp2Front = new Point(
+ points.cfWaistbandDipCp1Front.x * options.frontDipShape,
+ points.cfWaistbandDipFront.y
+ )
+ points.cfWaistbandDipCp1Front = points.cfWaistbandDipCp1Front.shiftFractionTowards(
+ points.sideWaistbandFront,
+ options.frontDipShape
+ )
+
+ /*
+ * Dip the waistband at the back
+ */
+ points.cfWaistbandDipCp1Back = utils.beamIntersectsX(
+ points.sideWaistbandBack,
+ points.sideLegBack.rotate(-90, points.sideWaistbandBack),
+ points.sideWaistbandBack.x / 2
+ )
+ points.cfWaistbandDipBack = new Point(
+ 0,
+ points.cfWaistbandDipCp1Back.y - waistToMiddle * options.backDip
+ )
+ points.cfWaistbandDipCp2Back = new Point(
+ points.cfWaistbandDipCp1Back.x * options.backDipShape,
+ points.cfWaistbandDipBack.y
+ )
+ points.cfWaistbandDipCp1Back = points.cfWaistbandDipCp1Back.shiftFractionTowards(
+ points.sideWaistbandBack,
+ options.backDipShape
+ )
+
+ /*
+ * We curve at the same angle as the front waistband dip here.
+ * Not doing so would mean that when the front exposure is high,
+ * and thus the fabric at the side gets narrow,
+ * Both curves would not be parallel which looks messy.
+ */
+ const dipAngle = points.sideLegFront.angle(points.sideWaistbandFront) + 90
+ points.sideLegCpFront = points.sideLegFront.shift(
+ dipAngle,
+ (points.sideGusset.dx(points.sideLegFront) / 3) * (1 - options.frontReduction)
+ )
+ points.sideLegCp1Back = points.sideLegBack.shift(
+ -dipAngle,
+ points.sideGusset.dx(points.sideLegBack) * 0.25
+ )
+
+ /*
+ * Now add the back gusset control point
+ */
+ points.gussetBackCp2 = points.sideGusset.shift(
+ 90,
+ points.sideLegCp1Back.dy(points.sideGusset) * 0.25
+ )
+
+ /*
+ * Make checking for bulge easy
+ */
+ store.set('bulge', options.bulge >= 2)
+
+ /*
+ * Construct the control points for the back curve.
+ * First create a simple back curve that mimics the one from Uma
+ */
+ paths.simpleBackCurve = new Path()
+ .move(points.sideLegBaseBack)
+ .curve(points.sideLegCp1Back, points.gussetBackCp2, points.sideGusset)
+ .hide()
+
+ const backMaxY = points.cfWaistbandDipBack.y - points.sideLegBase.dist(points.sideWaistbandBase)
+
+ /*
+ * Determine the default back curve center point and angle by probing a fraction along that curve
+ */
+ const curvePointFraction = 0.6
+ const epsilon = 0.01
+ points.backCurveCenterDefault = paths.simpleBackCurve.shiftFractionAlong(curvePointFraction)
+ const curvePointAngle = paths.simpleBackCurve
+ .shiftFractionAlong(curvePointFraction - epsilon)
+ .angle(paths.simpleBackCurve.shiftFractionAlong(curvePointFraction + epsilon))
+
+ /*
+ * Determine control point for maximum coverage
+ */
+ points.backCurveCenterMax = new Point(
+ points.sideLegBase.x * 0.7,
+ points.cfMiddle.shiftFractionTowards(points.sideLegBaseBack, 0.3).y
+ )
+ /*
+ * Determine control point for minimum coverage (thong-like)
+ */
+ points.backCurveCenterMin = points.cfWaistbandBack
+ .shiftFractionTowards(points.cfMiddle, 0.5)
+ .shift(0, minFabricWidth / 2)
+
+ /* This is the additional point */
+ points.sideFullnessBack = interpolatePoint(
+ points.backCurveCenterMax,
+ points.backCurveCenterDefault,
+ points.backCurveCenterMin,
+ options.backExposure
+ )
+
+ if (points.sideFullnessBack.y > backMaxY) {
+ points.sideFullnessBack = new Point(points.sideFullnessBack.x, backMaxY)
+ }
+
+ /* Determine the angle for the line at that point */
+ const shiftAngle = interpolateValue(160, curvePointAngle, 90, options.backExposure)
+ const shiftAmount =
+ points.cfSeat.dist(points.sideSeat) * interpolateValue(0.5, 0.1, 0.5, options.backExposure)
+
+ /* Determine control points */
+ points.sideLegCp2Back = points.sideFullnessBack.shift(shiftAngle, -shiftAmount)
+ if (points.sideLegCp2Back.y > backMaxY) {
+ points.sideLegCp2Back = new Point(points.sideLegCp2Back.x, backMaxY)
+ }
+ points.gussetBackCp1 = points.sideFullnessBack.shift(shiftAngle, shiftAmount)
+ points.gussetBackCp2 = points.sideGusset.shift(
+ 90,
+ points.sideFullnessBack.dy(points.sideGusset) / 4
+ )
+ points.gussetFrontCp = points.sideGusset.shift(
+ 90,
+ points.sideLegCpFront.dy(points.sideGusset) * options.frontExposure
+ )
+
+ /*
+ * Construct leg curve for the back part
+ */
+ paths.backCurve = new Path()
+ .move(points.sideLegBack)
+ .curve(points.sideLegCp1Back, points.sideLegCp2Back, points.sideFullnessBack)
+ .curve(points.gussetBackCp1, points.gussetBackCp2, points.sideGusset)
+ .hide()
+
+ /*
+ * Determine split point for crotch seam
+ */
+ const intersectsY = paths.backCurve.intersectsY(points.cfBackGusset.y)[0]
+
+ let backCurveParts = []
+ if (intersectsY && !Array.isArray(intersectsY)) {
+ points.backGussetSplit = intersectsY
+ backCurveParts = paths.backCurve.split(points.backGussetSplit)
+ }
+ if (!(backCurveParts && backCurveParts.length > 1)) {
+ points.backGussetSplit = points.sideGusset
+ backCurveParts = [paths.backCurve]
+ }
+
+ /*
+ * This is the part of the back curve that will be used for the back part
+ */
+ paths.elasticLegBack = backCurveParts[0].hide()
+
+ paths.back = new Path()
+ .move(points.cfWaistbandDipBack)
+ .curve(points.cfWaistbandDipCp2Back, points.cfWaistbandDipCp1Back, points.sideWaistbandBack)
+ .join(paths.elasticLegBack)
+ .line(points.cfBackGusset)
+ .hide()
+
+ // Determine center position of bulge
+ // TODO: Add measurement or make adjustable?
+ points.cfBulgeSplit = points.cfMiddle.shiftFractionTowards(points.cfHips, 0.5)
+
+ // Enforce minimum fabric width above bulge split
+ if (points.cfBulgeSplit.y < points.cfWaistbandDipFront.y + minFabricWidth) {
+ points.cfBulgeSplit = points.cfWaistbandDipFront.shift(-90, minFabricWidth)
+ }
+
+ points.rotationOrigin = new Point(points.sideGusset.x, points.cfBulgeSplit.y)
+
+ for (const pid of [
+ 'backGussetSplit',
+ 'cfMiddle',
+ 'cfGusset',
+ 'cfBackGusset',
+ 'sideGusset',
+ 'gussetFrontCp',
+ ]) {
+ if (store.get('bulge')) {
+ points[`${pid}Bulge`] = points[pid].rotate(options.bulge, points.rotationOrigin)
+ } else {
+ points[`${pid}Bulge`] = points[pid]
+ }
+ }
+
+ points.bulgeCp = points.cfBulgeSplit.shift(
+ -90,
+ points.cfBulgeSplit.dy(points.cfGussetBulge) * options.bulgeFullness
+ )
+
+ points.cfGussetBulgeCp = points.cfGussetBulge.shift(
+ 90 + options.bulge,
+ points.cfGussetBulge.dist(points.cfBulgeSplit) * 0.5
+ )
+
+ points.gussetFrontCpBulge = points.gussetFrontCpBulge.shiftFractionTowards(
+ points.sideGussetBulge,
+ options.bulge / 200
+ )
+
+ /*
+ * Rotate control points and bottom part of the back curve around the rotationOrigin to create the bulge
+ */
+ if (store.get('bulge')) {
+ points[`bulgeCpBulge`] = points['bulgeCp'].rotate(options.bulge, points.rotationOrigin)
+ } else {
+ points[`bulgeCpBulge`] = points['bulgeCp']
+ }
+
+ points.bulgeCpBottom = points.bulgeCpBulge
+ .shiftFractionTowards(points.bulgeCp, options.bulgeFullness)
+ .shiftFractionTowards(points.cfBulgeSplit, 0.5)
+
+ let rotatedPath
+ if (backCurveParts.length <= 1) {
+ rotatedPath = null
+ } else if (store.get('bulge')) {
+ rotatedPath = backCurveParts[1].rotate(options.bulge, points.rotationOrigin)
+ } else {
+ rotatedPath = backCurveParts[1]
+ }
+
+ paths.elasticLegFront = new Path().move(points.backGussetSplitBulge)
+
+ if (rotatedPath) {
+ paths.elasticLegFront = paths.elasticLegFront.join(rotatedPath)
+ }
+
+ paths.elasticLegFront
+ .curve(points.gussetFrontCpBulge, points.sideLegCpFront, points.sideLegFront)
+ .hide()
+
+ /*
+ * Construct pockets if desired
+ */
+ if (options.pockets !== 'none') {
+ points.sidePocketHeight = points.sideWaistbandFront.shiftTowards(
+ points.sideLegFront,
+ Math.min(
+ options.pocketHeight * points.cfHips.dist(points.cfSeat),
+ points.sideWaistbandFront.dist(points.sideLegFront) / 3
+ )
+ )
+ points.cfPocketHeight = points.cfWaistbandDipFront.shiftTowards(
+ points.cfMiddle,
+ points.sidePocketHeight.dist(points.sideWaistbandFront)
+ )
+ points.cfPocketHeightCp = new Point(
+ (points.sidePocketHeight.x / 2) * options.frontDipShape,
+ points.cfPocketHeight.y
+ )
+ if (expand) {
+ macro('mirror', {
+ mirror: [new Point(0, 0), new Point(0, 100)],
+ points: ['cfPocketHeightCp', 'sidePocketHeight'],
+ clone: true,
+ })
+
+ paths.pocketHeight = new Path()
+ .move(points.sidePocketHeight)
+ ._curve(points.cfPocketHeightCp, points.cfPocketHeight)
+ .curve_(points.mirroredCfPocketHeightCp, points.mirroredSidePocketHeight)
+ .reverse()
+ .addClass('help lining')
+ .addText('umbra:foldLining', 'center lining')
+ } else {
+ paths.pocketHeight = new Path()
+ .move(points.sidePocketHeight)
+ ._curve(points.cfPocketHeightCp, points.cfPocketHeight)
+ .reverse()
+ .addClass('help lining')
+ .addText('umbra:foldLining', 'center lining')
+ }
+ if (!complete) {
+ paths.pocketHeight.hide()
+ }
+
+ const pocketSeamX = points.sideHips.x * options.pocketGap
+ points.pocketSeamTop = new Path()
+ .move(points.sideWaistbandFront)
+ .curve(
+ points.cfWaistbandDipCp1Front,
+ points.cfWaistbandDipCp2Front,
+ points.cfWaistbandDipFront
+ )
+ .intersectsX(pocketSeamX)[0]
+
+ paths.pocketPilotPath = new Path()
+ .move(points.pocketSeamTop)
+ .curve_(
+ points.pocketSeamTop.shift(-80, measurements.crossSeamFront / 2),
+ new Point(points.sideLegFront.x, points.sideGussetBulge.y)
+ )
+ .setClass('mark')
+ .hide()
+
+ const intersects = paths.elasticLegFront.intersects(paths.pocketPilotPath)
+ if (intersects.length > 0) {
+ points.pocketSeamBottom = intersects[0]
+ paths.pocketPilotPath2 = new Path()
+ .move(points.pocketSeamBottom)
+ .line(points.pocketSeamBottom.shift(125, measurements.crossSeam))
+ .hide()
+ points.pocketSeamMiddle = paths.pocketPilotPath2.intersectsX(pocketSeamX)[0]
+
+ points.pocketSeamBottomCp = new Point(
+ pocketSeamX,
+ (points.pocketSeamBottom.y * 2 + points.pocketSeamMiddle.y) / 3
+ )
+
+ if (complete) {
+ paths.pocketShape = new Path()
+ .move(points.pocketSeamTop)
+ .line(points.pocketSeamMiddle)
+ .curve_(points.pocketSeamBottomCp, points.pocketSeamBottom)
+ .addClass('mark dashed')
+ .addText('umbra:pocketseam', 'center mark')
+ }
+
+ if (options.pockets === 'zipper') {
+ // Construct zipper path. This uses some absolute mm values as zipper widths are standardized.
+ // Let's assume a 5 mm zipper.
+ const zipperLeft = pocketSeamX + 10
+ const zipperRight = Math.min(
+ points.sidePocketHeight.x - 10,
+ zipperLeft + measurements.hips / 10
+ )
+ const a = paths.pocketHeight.intersectsX(zipperLeft)[0]
+ const b = paths.pocketHeight.intersectsX(zipperRight)[0]
+
+ const angle = a.angle(b)
+
+ points.leftZipperTop = a.shift(angle + 90, 2.5)
+ points.leftZipperBottom = points.leftZipperTop.shift(angle - 90, 5)
+ points.rightZipperTop = b.shift(angle + 90, 2.5)
+ points.rightZipperBottom = points.rightZipperTop.shift(angle - 90, 5)
+
+ if (complete) {
+ paths.zipper = new Path()
+ .move(points.leftZipperBottom)
+ .line(points.rightZipperBottom)
+ .line(points.rightZipperTop)
+ .line(points.leftZipperTop)
+ .close()
+ .reverse()
+ .addClass('mark dashed')
+ .addText('umbra:zipper', 'mark')
+
+ if (expand) {
+ macro('mirror', {
+ mirror: [new Point(0, 0), new Point(0, 100)],
+ points: ['leftZipperBottom', 'rightZipperBottom', 'rightZipperTop', 'leftZipperTop'],
+ clone: true,
+ })
+
+ paths.mirroredZipper = new Path()
+ .move(points.mirroredRightZipperTop)
+ .line(points.mirroredLeftZipperTop)
+ .line(points.mirroredLeftZipperBottom)
+ .line(points.mirroredRightZipperBottom)
+ .close()
+ .addClass('mark dashed')
+ .addText('umbra:zipper', 'mark')
+ }
+ }
+ paths.zipperCut = new Path()
+ .move(points.leftZipperBottom)
+ .line(points.leftZipperTop)
+ .move(points.rightZipperTop)
+ .line(points.rightZipperBottom)
+ .move(a)
+ .line(b)
+ .addClass('fabric')
+ paths.pocketHeight.hide()
+ }
+ }
+ }
+
+ // Compute elastic lengths
+ store.set(
+ 'waistbandElasticLength',
+ new Path()
+ .move(points.cfWaistbandDipBack)
+ .curve(points.cfWaistbandDipCp2Back, points.cfWaistbandDipCp1Back, points.sideWaistbandBack)
+ .move(points.cfWaistbandDipFront)
+ .curve(
+ points.cfWaistbandDipCp2Front,
+ points.cfWaistbandDipCp1Front,
+ points.sideWaistbandFront
+ )
+ .hide()
+ .length() *
+ 2 *
+ stretch.elastic
+ )
+
+ store.set(
+ 'legElasticLength',
+ (paths.elasticLegBack.length() + paths.elasticLegFront.length()) * stretch.elastic
+ )
+
+ /*
+ * Also flag this to the user, as well as the expand possibility
+ */
+ if (!expand) {
+ store.flag.preset('expandIsOff')
+ } else {
+ store.flag.preset('expandIsOn')
+ }
+ store.flag.note({
+ msg: `umbra:waistbandElasticLength`,
+ replace: { length: units(store.get('waistbandElasticLength')) },
+ })
+ store.flag.note({
+ msg: `umbra:legElasticLength`,
+ replace: { length: units(store.get('legElasticLength')) },
+ })
+ store.flag.note({
+ msg: `umbra:minStretch`,
+ replace: {
+ pct: Math.round(100 * (measurements.seat / store.get('waistbandElasticLength') - 1)) + '%',
+ },
+ })
+
+ /*
+ * Hide this part, others will extend it
+ */
+ return part
+}
+
+export const base = {
+ name: 'umbra.base',
+ measurements: [
+ 'waist',
+ 'seat',
+ 'waistToSeat',
+ 'crossSeam',
+ 'crossSeamFront',
+ 'waistToHips',
+ 'hips',
+ ],
+ options: {
+ // Fit options
+
+ /*
+ * xStretch is for the horizontal fabric stretch
+ */
+ xStretch: { pct: 15, min: 0, max: 75, menu: 'fit' },
+
+ /*
+ * yStretch is for the vertical fabric stretch
+ */
+ yStretch: { pct: 5, min: 0, max: 50, menu: 'fit' },
+
+ /*
+ * additional stretch factor for the elastics
+ */
+ elasticStretch: { pct: 5, min: 0, max: 10, menu: 'fit' },
+
+ /*
+ * gussetPosition allows you to shift the gusset towards the front or back
+ */
+ gussetPosition: { pct: 50, min: 20, max: 100, menu: 'fit' },
+
+ /*
+ * The gusset width, based on the crossSeam measurement
+ */
+ gussetWidth: {
+ pct: 12,
+ min: 3,
+ max: 20,
+ menu: 'fit',
+ toAbs: (val, { measurements }, mergedOptions) =>
+ measurements.crossSeam * mergedOptions.gussetWidth * stretchToScale(mergedOptions.xStretch),
+ },
+
+ /*
+ * splitPosition allows you to shift the split towards the front or back
+ */
+ splitPosition: { pct: 11, min: 0, max: 45, menu: 'fit' },
+
+ /*
+ * The bulge option allows you to create room in the front
+ * to keep for a snack, or other things you might want to carry there.
+ */
+ bulge: { deg: 0, min: 0, max: 30, menu: 'fit' },
+
+ /*
+ * This option allows you to create extra room in the bulge
+ */
+ bulgeFullness: {
+ pct: 75,
+ min: 25,
+ max: 100,
+ menu: (settings, mergedOptions) => (mergedOptions?.bulge < 2 ? false : 'fit'),
+ },
+
+ // Style options
+
+ /*
+ * The minimum fabric width of the thong and waistband part.
+ * Only has an effect when the back exposure is low or the leg rise is high.
+ */
+ minFabricWidth: {
+ pct: 2,
+ min: 0.5,
+ max: 5,
+ menu: 'style',
+ toAbs: (val, { measurements }) => measurements.seat * val,
+ },
+
+ /*
+ * frontReduction determines how much less wide the front part is compared to the back part
+ * This can improve fit and make the appearance slimmer, but potentially reduces the size of pockets
+ */
+ frontReduction: { pct: 10, min: 0, max: 30, menu: 'style' },
+
+ /*
+ * Rise controls the waist height
+ */
+ rise: {
+ pct: 75,
+ min: 20,
+ max: 150,
+ menu: 'style',
+ toAbs: (val, { measurements }, mergedOptions) =>
+ (measurements.crossSeam / 2 -
+ measurements.waistToSeat +
+ (measurements.waistToSeat - measurements.waistToHips) * mergedOptions.rise) *
+ stretchToScale(mergedOptions.xStretch),
+ },
+
+ /*
+ * legRise controls how high the leg opening is cut out
+ */
+ legRise: { pct: 0, min: -20, max: 40, menu: 'style' },
+
+ /*
+ * Front dip dips the front waistband
+ */
+ frontDip: { pct: 2.5, min: -5, max: 15, menu: 'style' },
+
+ /*
+ * Determines the shape of the front dip
+ */
+ frontDipShape: { pct: 75, min: 0, max: 95, menu: 'style' },
+
+ /*
+ * frontExposure determines how much skin is on display at the front
+ * Note that frontDip will also influence this
+ */
+ frontExposure: { pct: 70, min: 5, max: 100, menu: 'style' },
+
+ /*
+ * Front dip dips the back waistband
+ */
+ backDip: { pct: -2.5, min: -15, max: 10, menu: 'style' },
+
+ /*
+ * Determines the shape of the back dip
+ */
+ backDipShape: { pct: 80, min: 0, max: 95, menu: 'style' },
+
+ /*
+ * backExposure determines how much skin is on display at the back
+ * Note that backDip will also influence this
+ */
+ backExposure: { pct: 15, min: 0, max: 100, menu: 'style' },
+
+ pockets: {
+ dflt: 'none',
+ list: ['none', 'inside', 'zipper'],
+ menu: 'style',
+ extraNote: 'Select if you want pockets',
+ },
+
+ pocketGap: {
+ pct: 25,
+ min: 15,
+ max: 35,
+ menu: (settings, mergedOptions) => (mergedOptions?.pockets === 'none' ? false : 'style'),
+ toAbs: (val, { measurements }, mergedOptions) =>
+ (measurements.hips / 2) * mergedOptions.pocketGap * stretchToScale(mergedOptions.xStretch),
+ },
+
+ pocketHeight: {
+ pct: 20,
+ min: 10,
+ max: 30,
+ menu: (settings, mergedOptions) => (mergedOptions?.pockets === 'none' ? false : 'style'),
+ },
+
+ /*
+ * If the back part should be flipped
+ */
+ flipBack: {
+ menu: 'advanced',
+ bool: true,
+ extraNote:
+ 'Select if the back part should be flipped into upright orientation, set to false for development and easier debugging of control points',
+ },
+ },
+ draft: draftUmbraBase,
+ hide: { self: true },
+}
diff --git a/designs/umbra/src/front.mjs b/designs/umbra/src/front.mjs
new file mode 100644
index 00000000000..07afd2d66ee
--- /dev/null
+++ b/designs/umbra/src/front.mjs
@@ -0,0 +1,232 @@
+import { base } from './base.mjs'
+
+export const front = {
+ name: 'umbra.front',
+ from: base,
+ draft: draftUmbraFront,
+}
+
+/*
+ * This drafts the front of Umbra, or rather recycles what's needed from base
+ */
+function draftUmbraFront({
+ Point,
+ Path,
+ points,
+ paths,
+ store,
+ sa,
+ Snippet,
+ snippets,
+ options,
+ expand,
+ macro,
+ units,
+ part,
+}) {
+ if (store.get('bulge')) {
+ paths.seamBase = new Path()
+ .move(points.cfBulgeSplit)
+ .curve(points.bulgeCpBottom, points.cfGussetBulgeCp, points.cfGussetBulge)
+ .line(points.cfBackGussetBulge)
+ } else {
+ paths.seamBase = new Path().move(points.cfBackGussetBulge)
+ }
+ paths.seamBase = paths.seamBase
+ .line(points.backGussetSplitBulge)
+ .join(paths.elasticLegFront)
+ .line(points.sideWaistbandFront)
+ .curve(points.cfWaistbandDipCp1Front, points.cfWaistbandDipCp2Front, points.cfWaistbandDipFront)
+ .hide()
+ if (expand) {
+ macro('mirror', {
+ mirror: [new Point(0, 0), new Point(0, 100)],
+ paths: ['seamBase'],
+ clone: true,
+ })
+ paths.seam = paths.seamBase.join(paths.mirroredSeamBase.reverse())
+ paths.mirroredSeamBase.hide()
+
+ macro('mirror', {
+ mirror: [new Point(0, 0), new Point(0, 100)],
+ paths: ['pocketShape', 'zipperCut'],
+ points: ['pocketTop'],
+ clone: true,
+ })
+ } else {
+ paths.seam = paths.seamBase.clone().close()
+ }
+ paths.seam.unhide().addClass('fabric')
+ if (sa) {
+ paths.saBase = new Path()
+ .move(points.cfBackGussetBulge)
+ .line(points.backGussetSplitBulge)
+ .join(paths.elasticLegFront)
+ .line(points.sideWaistbandFront)
+ .curve(
+ points.cfWaistbandDipCp1Front,
+ points.cfWaistbandDipCp2Front,
+ points.cfWaistbandDipFront
+ )
+ .hide()
+
+ if (expand) {
+ macro('mirror', {
+ mirror: [new Point(0, 0), new Point(0, 100)],
+ paths: ['saBase'],
+ clone: true,
+ })
+ paths.saBase = paths.saBase.join(paths.mirroredSaBase.reverse()).close().hide()
+ paths.sa = paths.saBase.offset(sa).setClass('fabric sa').unhide()
+ } else {
+ paths.sa = paths.saBase
+ .offset(sa)
+ .reverse()
+ .line(new Point(0, points.cfBackGussetBulge.y))
+ .line(points.cfBulgeSplit)
+ .reverse()
+ .line(points.cfWaistbandDipFront)
+ .setClass('fabric sa')
+ .unhide()
+ }
+ }
+ store.cutlist.setCut({ cut: 1, from: 'fabric', onFold: !expand })
+ store.cutlist.addCut({ cut: 1, from: 'lining', onFold: !expand })
+ points.title = points.cfWaistbandDipFront.shift(-45, 20).shift(-90, 40)
+ if (expand) {
+ macro('grainline', {
+ to: store.get('bulge') ? points.cfBulgeSplit : points.cfBackGusset,
+ from: points.cfWaistbandDipFront,
+ })
+ } else {
+ macro('cutonfold', {
+ to: store.get('bulge') ? points.cfBulgeSplit : points.cfBackGusset,
+ from: points.cfWaistbandDipFront,
+ grainline: true,
+ })
+ }
+ macro('hd', {
+ id: 'wAtWaistband',
+ from: points.cfWaistbandDipFront,
+ to: points.sideWaistbandFront,
+ y: points.sideWaistbandFront.y - sa - 15,
+ })
+
+ macro('vd', {
+ id: 'grainline',
+ from: points.cfWaistbandDipFront,
+ to: points.cfBackGussetBulge,
+ x: -30,
+ })
+
+ if (store.get('bulge')) {
+ macro('vd', {
+ id: 'grainline2',
+ from: points.cfWaistbandDipFront,
+ to: points.cfBulgeSplit,
+ x: -15,
+ })
+ }
+
+ macro('vd', {
+ id: 'outer',
+ from: points.sideWaistbandFront,
+ to: points.sideLegFront,
+ x: points.sideSeat.x + 15,
+ })
+
+ if (options.frontDip !== 0) {
+ macro('vd', {
+ id: 'outer2',
+ from: points.cfWaistbandDipFront,
+ to: points.sideLegFront,
+ x: points.sideSeat.x,
+ })
+ }
+
+ macro('vd', {
+ id: 'waistbandDip',
+ from: points.cfWaistbandDipFront,
+ to: points.sideWaistbandFront,
+ x: -15,
+ })
+
+ macro('vd', {
+ id: 'heightToWaist',
+ from: points.cfWaistbandDipFront,
+ to: points.backGussetSplitBulge,
+ x: points.backGussetSplitBulge.x,
+ })
+
+ macro('hd', {
+ id: 'heightToSideLeg',
+ from: points.backGussetSplitBulge,
+ to: points.sideLegFront,
+ y: points.backGussetSplitBulge.y,
+ })
+
+ if (options.bulge >= 2) {
+ macro('hd', {
+ id: 'bulgeHeight',
+ from: points.cfBulgeSplit,
+ to: points.cfBackGussetBulge,
+ y: points.cfBackGussetBulge.y + 15,
+ })
+ }
+
+ macro('hd', {
+ id: 'backGusset',
+ to: points.backGussetSplitBulge,
+ from: points.cfBackGussetBulge,
+ y: points.cfBackGussetBulge.y + 15,
+ })
+
+ let frontCenter = points.sideWaistbandFront.shiftFractionTowards(points.sideLegFront, 0.5)
+ snippets.sideFrontCenter = new Snippet('notch', frontCenter)
+ if (expand) {
+ snippets.sideFrontCenterMirrored = new Snippet(
+ 'notch',
+ new Point(-frontCenter.x, frontCenter.y)
+ )
+ }
+
+ if (points.pocketSeamBottom) {
+ snippets.pocketTop = new Snippet('notch', points.pocketSeamTop)
+ snippets.pocketBottom = new Snippet('notch', points.pocketSeamBottom)
+ if (expand) {
+ snippets.pocketTopMirrored = new Snippet(
+ 'notch',
+ new Point(-points.pocketSeamTop.x, points.pocketSeamTop.y)
+ )
+ snippets.pocketBottomMirrored = new Snippet(
+ 'notch',
+ new Point(-points.pocketSeamBottom.x, points.pocketSeamBottom.y)
+ )
+ }
+ }
+
+ /*
+ * Clean up paths from base
+ */
+ delete paths.back
+ delete paths.front
+ delete paths.saBase
+
+ /*
+ * Title
+ */
+ macro('title', {
+ at: points.title,
+ nr: 1,
+ title: 'front',
+ notes: [
+ 'umbra:waistbandMeasure',
+ units(store.get('waistbandElasticLength')),
+ '\n',
+ 'umbra:legMeasure',
+ units(store.get('legElasticLength')),
+ ],
+ })
+
+ return part
+}
diff --git a/designs/umbra/src/index.mjs b/designs/umbra/src/index.mjs
new file mode 100644
index 00000000000..faf32fbca8f
--- /dev/null
+++ b/designs/umbra/src/index.mjs
@@ -0,0 +1,28 @@
+import { Design } from '@freesewing/core'
+import { i18n } from '../i18n/index.mjs'
+import { base } from './base.mjs'
+import { back } from './back.mjs'
+import { front } from './front.mjs'
+import { data } from '../data.mjs'
+
+/*
+ * Let core bake a new design for us
+ */
+const Umbra = new Design({
+ data,
+ parts: [base, back, front],
+})
+
+/*
+ * Named exports
+ */
+export {
+ // Individual parts
+ base,
+ back,
+ front,
+ // The Umbra design itself
+ Umbra,
+ // Translations
+ i18n,
+}
diff --git a/designs/umbra/tests/shared.test.mjs b/designs/umbra/tests/shared.test.mjs
new file mode 100644
index 00000000000..77dd2467aa0
--- /dev/null
+++ b/designs/umbra/tests/shared.test.mjs
@@ -0,0 +1,20 @@
+// This file is auto-generated | Any changes you make will be overwritten.
+import { Umbra, i18n } from '../src/index.mjs'
+
+// Shared tests
+import { testPatternConfig } from '../../../tests/designs/config.mjs'
+import { testPatternI18n } from '../../../tests/designs/i18n.mjs'
+import { testPatternDrafting } from '../../../tests/designs/drafting.mjs'
+import { testPatternSampling } from '../../../tests/designs/sampling.mjs'
+
+// Test config
+testPatternConfig(Umbra)
+
+// Test translation
+testPatternI18n(Umbra, i18n)
+
+// Test drafting - Change the second parameter to `true` to log errors
+testPatternDrafting(Umbra, false)
+
+// Test sampling - Change the second parameter to `true` to log errors
+testPatternSampling(Umbra, false)
diff --git a/markdown/org/docs/designs/umbra/cutting/de.md b/markdown/org/docs/designs/umbra/cutting/de.md
new file mode 100644
index 00000000000..0b2fbb1b99a
--- /dev/null
+++ b/markdown/org/docs/designs/umbra/cutting/de.md
@@ -0,0 +1,28 @@
+---
+title: "Umbra Unterhosen: Schnittanleitung"
+---
+
+Umbra besteht aus einem Rückenteil und einem gefütterten Vorderteil.
+Dies ist die Schnittliste:
+
+- **Hauptstoff**
+ - Schneide **1 Vorderteil**
+ - Schneide **1 Rückenteil**
+- **Futterstoff**
+ - Schneide **1 Vorderteil**
+
+Wenn du einen Overlock verwendet, kannst du überschüssigen Stoff mit dem Messer wegschneiden, verwende also eine normale Nahtzugabe.
+
+Wenn du keinen Overlock hast, empfehle ich dir, eine Nahtzugabe von 5 mm mit einem Overlook-Fuß und einem dehnbaren Kanten- bzw. Fake-Overlock-Stich zu verwenden.
+
+Je nachdem, wie du die Beinnähte abschließen möchtest, ist es in der Regel eine gute Idee, die Nahtzugabe an den Beinen des Futterteils wegzulassen, da der vordere Stoff nach innen umschlagen wird und dadurch die Kante versäubert wird.
+Wenn du für den Beinausschnitt ein umgeschlagenes Gummiband verwenden möchtest, lasse die Nahtzugabe für die Beinöffnung an allen Teilen weg.
+
+
+
+##### Notizen
+
+- Umbra ist ein großartiger Resteverwerter. Wenn du Stoffreste von einem [Teagan-T-Shirt](/designs/teagan/) oder irgendetwas aus einem dehnbaren Jersey-Stoff hast, ist dies eine gute Möglichkeit, diese zu verwenden. Wenn Sie nur kleinere Stücke haben, kannst du die beiden Hälften auch separat zuschneiden und zusammennähen, anstatt die Stücke im Stoffbruch zuzuschneiden. Dadurch entstehen jedoch zusätzliche Nähte.
+- Du kannst denselben Stoff für das gesamte Kleidungsstück verwenden, auch für das vordere Futter. Manche Menschen ziehen es vor, weichere Stoffe oder andere Materialien für das Futter zu verwenden.
+
+
diff --git a/markdown/org/docs/designs/umbra/cutting/en.md b/markdown/org/docs/designs/umbra/cutting/en.md
new file mode 100644
index 00000000000..9adf9c21c01
--- /dev/null
+++ b/markdown/org/docs/designs/umbra/cutting/en.md
@@ -0,0 +1,27 @@
+---
+title: "Umbra undies: Cutting Instructions"
+---
+
+Umbra consists of a back piece and a lined front piece.
+This is the cut list:
+
+- **Main fabric**
+ - Cut **1 front**
+ - Cut **1 back**
+- **Lining fabric**
+ - Cut **1 front**
+
+If you use a serger, you can cut away excess fabric with the knife, so use standard seam allowance.
+
+If you don't have a serger, I recommend using an overlook foot and a flexible overedge / fake overlock stitch with a seam allowance equal to the width of that stitch (usually 5 mm).
+
+If you want to finish the leg openings with fold over elastics, you may want to skip the seam allowance for the leg opening on all parts.
+
+
+
+##### Notes
+
+- Umbra is a great scrap buster. If you have fabric scraps from making a [Teagan t-shirt](/designs/teagan/) or anything from a jersey fabric that has good stretch, this is a good way to use those up. If you only have smaller pieces, instead of cutting the pieces on the fold, you can cut both halves separately and sew them together. However, this introduces additional seams.
+- You can use the same fabric for the whole garment, including the front lining. Some people prefer using softer fabrics or different materials for the lining.
+
+
diff --git a/markdown/org/docs/designs/umbra/de.md b/markdown/org/docs/designs/umbra/de.md
new file mode 100644
index 00000000000..0810f8c3de0
--- /dev/null
+++ b/markdown/org/docs/designs/umbra/de.md
@@ -0,0 +1,8 @@
+---
+title: "Umbra Unterhosen"
+---
+
+
+
+
+Be sure to adjust the "horizontal fabric stretch" and "vertical fabric stretch" options according to your fabric. Do **not** enter the max fabric stretch, enter the stretch you want the fabric to be when worn.
+
+
+If you have fabric with over 100% stretch, a good value for the horizontal stretch is 30%-50%.
+If you have fabric with around 80% stretch, a good default value for the horizontal stretch is 30%.
+If your fabric has 30% stretch, choose 15% horizontal stretch or less.
+If you want to use zipper pockets, go with a low stretch as the zippers can't stretch themselves.
+
+Fabric will wear out fast if you wear it near its maximum stretch, it will also be very uncomfortable.
+
+Note that the thickness of the fabric also affects the stretch you should enter. Go with lower stretch for thicker fabric.
+
+The vertical stretch can be much lower than the horizontal stretch. If you use a fabric that stretches more in one direction, use that for the horizontal direction.
+A good general value for the vertical stretch is around 5%. If it is too high, the fabric may press uncomfortably against your crotch area.
+
+
+* If you use a different fabric for the lining, make sure it has around the same stretch as the outer fabric.
+* If you use the same fabric for the lining, make sure to mark the lining piece, as otherwise both pieces may get confused easily during sewing.
+
diff --git a/markdown/org/docs/designs/umbra/instructions/en.md b/markdown/org/docs/designs/umbra/instructions/en.md
new file mode 100644
index 00000000000..b0b76ad8209
--- /dev/null
+++ b/markdown/org/docs/designs/umbra/instructions/en.md
@@ -0,0 +1,110 @@
+---
+title: "Umbra undies: Sewing Instructions"
+---
+
+### Step 1: Sew the bulge
+
+If you have selected the bulge option, sew together the seam/dart between the bulge split and the crotch with _good sides together_. Do this for both front pieces separately. Trim seam allowance if necessary.
+
+Skip this step if your design doesn't have a bulge.
+
+
+
+### Step 2: Prepare pocket
+
+If you don't want pockets, skip to step 3.
+
+#### If you want to have inside pockets
+
+On the front piece from the lining fabric, fold down the seam allowance on the top edge, _bad sides together_, then fix using an elastic stitch.
+
+Create an additional fold, around 1.5 cm below the top or around the marked edge to the same side. Press that fold, but do not sew.
+
+
+
+#### If you want to have zipper pockets
+
+Of the front piece of the main fabric, insert twp zippers at the marked location.
+There are various techniques to do this. You may want to add some fusible interfacing on the bad side to make the fabric around the zipper more robust and less elastic.
+
+### Step 3: Stack fabrics
+
+Stack the parts in the following way, aligning and pinning the side seams and the crotch seams.
+
+* On the table, place the front part with lining fabric, _good side up_
+* On top of that, place the back part, _good side up_
+* On top of that, place the front part with main fabric, _bad side up_
+
+To double-check, the main fabric front part and the back part should have their _good sides together_ and the good side of the lining fabric should point towards the middle piece. The front parts on the outside of the stack should have their respective bad side pointing outwards, away from the back piece in the middle.
+
+Depending on your settings, the middle (back) part in your stack has likely a shorter crotch part and wider sides than the outer parts. Make sure to sandwich all three layers together on the future seams. You probably have to bunch up the fabric a bit.
+
+
+
+### Step 4: Sew the parts together
+
+Sew the crotch seam and both side seams together. Use a serger or a flexible stitch.
+
+
+
+### Step 5: Turn it the right side out
+
+Take only the main fabric front part (on top of the stack) and reverse the crotch part of it through the waistline opening, so that the bad sides of both front pieces are together. All seams should now be hidden between both front pieces.
+
+This should now roughly look like underwear.
+
+
+
+### Step 6: Create Pocket seams
+
+If you have selected a pocket option, sew front and lining together along the marked pocket seams using a coverstitch or an elastic stitch.
+
+
+
+### Step 7: Finish the leg seams
+
+You have several options for finishing the leg openings.
+
+#### Option A: Fold it over
+
+If you don't want to use an elastic band for the legs, you can as a simple option fold the seam allowance to the inside of the briefs and fix it using an elastic stitch. However some fabrics could warp with bad presser foot pressure and thread tension settings, so while this option is easy, it might not give the best results.
+
+#### Option B: Use an elastic band
+
+Another better option is to use a decorative elastic band. In this case follow [steps 8 to 10 from the Uma instructions](/docs/designs/uma/instructions#step-8-prepare-elastic) for the leg openings.
+
+#### Option C: Bias tape
+
+You can also use elastic fold-over bias tape, in which case you should trim all seam allowances on the leg openings to keep the intended shape.
+
+### Step 8: Prepare elastic for the waist
+
+Overlap the edges of each piece of your waistband elastic by your seam allowance and stitch together.
+
+To ensure that you stretch the elastic evenly, divide the waistband opening and your elastic into four quarters and mark the points with pins or chalk.
+
+
+
+### Step 9: Sew elastic for the waistband
+
+Choose if you want to have the elastic on the inside or on the outside on the finished undies. Smaller elastic bands should typically go on the inside, larger ones on the outside. The following pictures assume you want the elastic on the outside.
+
+If you want to have the elastic on the outside, pin the bad side of the elastics to the bad side of the fabric. If you want to have the elastic on the inside, join both good sides.
+
+If your elastic has a decorative edge, make sure that you line up the plain edge (not the decorative edge) of the elastic to the raw edge of the fabric. The decorative edge should be pointing towards the garment, not away from it.
+
+Pin the elastic to the waist opening of the fabric on the selected side, ensuring that you line up the quarter markings. It can be very helpful to stitch it on by hand so your elastic is kept in place properly for the next step.
+
+Sew the elastic to the garment using an elastic stitch. You will have to stretch the elastic slightly as you sew to make it lay flat against the fabric. Avoid stretching the fabric itself.
+
+
+
+Trim away any excess fabric that causes bulk or sticks out from the elastic.
+
+### Step 10: Fold the elastic inwards and sew it down again
+
+Fold the elastic and fabric to the other side, enclosing the raw edge of the fabric under the elastic. Sew again using an elastic stitch.
+
+
+
+You did it!
diff --git a/markdown/org/docs/designs/umbra/instructions/step01.svg b/markdown/org/docs/designs/umbra/instructions/step01.svg
new file mode 100644
index 00000000000..8cb2b72f23b
--- /dev/null
+++ b/markdown/org/docs/designs/umbra/instructions/step01.svg
@@ -0,0 +1,721 @@
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
diff --git a/markdown/org/docs/designs/umbra/instructions/step02.svg b/markdown/org/docs/designs/umbra/instructions/step02.svg
new file mode 100644
index 00000000000..58592304dd9
--- /dev/null
+++ b/markdown/org/docs/designs/umbra/instructions/step02.svg
@@ -0,0 +1,710 @@
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
diff --git a/markdown/org/docs/designs/umbra/instructions/step03.svg b/markdown/org/docs/designs/umbra/instructions/step03.svg
new file mode 100644
index 00000000000..1efdc89d346
--- /dev/null
+++ b/markdown/org/docs/designs/umbra/instructions/step03.svg
@@ -0,0 +1,728 @@
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
diff --git a/markdown/org/docs/designs/umbra/instructions/step04.svg b/markdown/org/docs/designs/umbra/instructions/step04.svg
new file mode 100644
index 00000000000..f7b069d9927
--- /dev/null
+++ b/markdown/org/docs/designs/umbra/instructions/step04.svg
@@ -0,0 +1,727 @@
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
diff --git a/markdown/org/docs/designs/umbra/instructions/step05.svg b/markdown/org/docs/designs/umbra/instructions/step05.svg
new file mode 100644
index 00000000000..bbe60ef0999
--- /dev/null
+++ b/markdown/org/docs/designs/umbra/instructions/step05.svg
@@ -0,0 +1,748 @@
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
diff --git a/markdown/org/docs/designs/umbra/instructions/step06.svg b/markdown/org/docs/designs/umbra/instructions/step06.svg
new file mode 100644
index 00000000000..ca8a202e1e7
--- /dev/null
+++ b/markdown/org/docs/designs/umbra/instructions/step06.svg
@@ -0,0 +1,724 @@
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
diff --git a/markdown/org/docs/designs/umbra/instructions/step08.svg b/markdown/org/docs/designs/umbra/instructions/step08.svg
new file mode 100644
index 00000000000..9568bcff3f8
--- /dev/null
+++ b/markdown/org/docs/designs/umbra/instructions/step08.svg
@@ -0,0 +1,804 @@
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
diff --git a/markdown/org/docs/designs/umbra/instructions/step09.svg b/markdown/org/docs/designs/umbra/instructions/step09.svg
new file mode 100644
index 00000000000..d9e6bb38705
--- /dev/null
+++ b/markdown/org/docs/designs/umbra/instructions/step09.svg
@@ -0,0 +1,704 @@
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
diff --git a/markdown/org/docs/designs/umbra/instructions/step10.svg b/markdown/org/docs/designs/umbra/instructions/step10.svg
new file mode 100644
index 00000000000..c3a7b4e2029
--- /dev/null
+++ b/markdown/org/docs/designs/umbra/instructions/step10.svg
@@ -0,0 +1,970 @@
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
diff --git a/markdown/org/docs/designs/umbra/measurements/de.md b/markdown/org/docs/designs/umbra/measurements/de.md
new file mode 100644
index 00000000000..aed22528a11
--- /dev/null
+++ b/markdown/org/docs/designs/umbra/measurements/de.md
@@ -0,0 +1,15 @@
+---
+title: "Umbra Unterhosen: Erforderliche Maße"
+---
+
+
+Vergewissere dich, dass deine Maße auf einer definierten Taille beruhen. Wenn du Schwierigkeiten hast, deine Taille zu bestimmen, binde eine Schnur in ungefähr korrekter Höhe um deinen Körper (in der Regel etwas unterhalb der Rippen oder dort, wo sich die Haut faltet, wenn du dich zur Seite beugst).
+Verwende dies als Bezugslinie für die anderen Messungen.
+Die genaue Taillenhöhe ist nicht entscheidend, aber sie ist wichtig, um die Konsistenz der anderen Messungen zu gewährleisten.
+
+
+
+Beim Taille-Schritt-Taille-Maß solltest du deine Genitalien nicht mitmessen. Führe das Maßband an der Innenseite eines Beins entlang und nicht über die Körpermitte. Zusätzlicher Raum vorne kann mit der Option "Wölbung" geschaffen werden.
+
diff --git a/markdown/org/docs/designs/umbra/measurements/en.md b/markdown/org/docs/designs/umbra/measurements/en.md
new file mode 100644
index 00000000000..2dc5ebcc5b7
--- /dev/null
+++ b/markdown/org/docs/designs/umbra/measurements/en.md
@@ -0,0 +1,15 @@
+---
+title: "Umbra undies: Required Measurements"
+---
+
+
+Ensure that yor measurements are based on a fixed waistline. If you have difficulty determining where your waist is, tie a string around your body at approximately the right height (usually a little below the ribs or where your skin folds if you bend sideways).
+Use this as a reference line for the other measurements.
+The exact waist height is not crucial, but it is essential to maintain consistency in the other measurements.
+
+
+
+To measure the cross seam precisely, exclude your genitals. Place the measuring tape alongside the inside of one of your legs, rather than over the center of your body. Extra room for your genitals can be added through the bulge option.
+
diff --git a/markdown/org/docs/designs/umbra/needs/de.md b/markdown/org/docs/designs/umbra/needs/de.md
new file mode 100644
index 00000000000..435708f7670
--- /dev/null
+++ b/markdown/org/docs/designs/umbra/needs/de.md
@@ -0,0 +1,21 @@
+---
+title: "Umbra Unterhosen: Was du brauchst"
+---
+
+Um Umbra herzustellen, brauchst du Folgendes:
+
+- [Grundlegendes Nähzubehör](/docs/sewing/basic-sewing-supplies)
+- Etwa 0,7 Meter (0,8 Yards) eines geeigneten Stoffes (siehe [Stoffoptionen](/docs/designs/umbra/fabric))
+- Ungefähr 3 Meter (3,3 Yards) Unterwäsche-Gummiband, z. B. ein Picot-Gummiband oder ein umklappbares Gummiband
+
+
+
+##### Bindungsmethoden können die Nahterlaubnis
+
+beeinflussen, wenn Falten über elastisch (FOE) verwendet wird oder Strickverbindung, Sie können vor dem Schneiden die Naht an den Beinen und die Taille abschneiden wollen. Wenn du die Nahtzugabe beibehältst, wird das fertige Produkt eine etwas höhere Taille und etwas kleinere Beinöffnungen haben.
+
+##### Overlocks (Serger) sind schön, aber optional
+
+Wie bei allen Strickwaren und Stretchgeweben wird dir eine Overlock (Serger) das Leben erleichtern. Wenn du keine hast, musst du aber nicht verzweifeln. Du brauchst sie nicht unbedingt. Du kannst Umbra einfach mit einem Zickzackstich nähen.
+
+
diff --git a/markdown/org/docs/designs/umbra/needs/en.md b/markdown/org/docs/designs/umbra/needs/en.md
new file mode 100644
index 00000000000..6e5a3f135ea
--- /dev/null
+++ b/markdown/org/docs/designs/umbra/needs/en.md
@@ -0,0 +1,21 @@
+---
+title: "Umbra undies: What You Need"
+---
+
+To make Umbra, you will need the following:
+
+- [Basic sewing supplies](/docs/sewing/basic-sewing-supplies)
+- About 0.7 meters (0.8 yards) of a suitable fabric (see [Fabric options](/docs/designs/umbra/fabric))
+- About 3 meters (3.3 yards) of underwear elastic, such as picot elastic or fold over elastic
+
+
+
+##### Binding methods may affect the seam allowance
+
+If using fold over elastic (FOE) or doing knit binding, you may wish to trim away the seam allowance at the legs and waist before cutting. If you keep the seam allowance, the finished product will have a slightly higher waist and slightly smaller leg openings.
+
+##### A serger/overlock is nice, but optional
+
+As with all knitwear and stretch fabrics, a serger/overlock will make your life easier. If you do not have one of those, don't despair. You don't really need it. You can just sew Umbra with a zigzag stitch or with various other stretch stitches.
+
+
diff --git a/markdown/org/docs/designs/umbra/notes/de.md b/markdown/org/docs/designs/umbra/notes/de.md
new file mode 100644
index 00000000000..e7cf5852dc2
--- /dev/null
+++ b/markdown/org/docs/designs/umbra/notes/de.md
@@ -0,0 +1,31 @@
+---
+title: "Umbra Unterhosen: Designer Notes"
+---
+
+Umbra ist ein bequemer und flexibler Slip, der so vielen Menschen wie möglich gerecht werden soll.
+
+Umbra basiert auf einigen Experimenten, Prototypen und Messungen an meiner Lieblingsunterwäsche.
+
+Umbra ist speziell für vielfältige Nutzer konzipiert. Du kannst das Design für dich einfach auf verschiedene Weise anpassen um deinen Bedürfnissen gerecht zu werden. Jedoch werden nicht alle Anpassungen direkt in der Software unterstützt.
+
+Einige Funktionen von Umbra sind wie folgt:
+
+* Umbra kann so genäht werden, dass keine (potenziell juckende) Nahtzugabe die Haut berührt, was unter anderem Menschen mit empfindlicher Haut und mit sensorischen Problemen wie bei Autismus hilft. Die Schritt- und Seitennähte liegen innen zwischen den Lagen des Vorderteils und eventuelle Gummizüge an der Taille und den Beinöffnungen können auf Wunsch auf der Außenseite angebracht werden.
+* Umbra kann mit oder ohne Wölbung genäht werden. Du kannst das Design sogar zweimal entwerfen und das Vorderfutter ohne Wölbung und das Hauptstoff-Vorderteil mit Wölbung zuschneiden, und dadurch eine Vordertasche mit viel Platz schaffen.
+* Höhe, Rückenausschnitt, Vorderausschnitt und Zwickelbreite werden separat gesteuert, sodass z. B. sehr bequeme Tangas mit genügend Platz im Vorderteil oder viele andere Designs erstellt werden können.
+
+Umbra basiert auf dem Code von Uma von Natalia Sayang und Joost De Cock, wurde aber in seinem Aufbau und Standard-Design stark verändert.
+Einige Hauptunterschiede sind:
+* Umbra hat keinen separaten Zwickelteil, stattdessen wird das ganze Vorderteil mit Futter versehen.
+* Die Hüftmaße werden berücksichtigt, um die Weite des Bundes besser bestimmen zu können.
+* Die Höhe der Unterwäsche basiert auf dem normalerweise genaueren Taille-Schritt-Taille-Maß anstelle des Maßes von Taille bis Oberschenkel.
+* Die Positionen der Seiten- und Schrittnähte können frei eingestellt werden, auch wenn eine Wölbung gewählt wurde.
+* Das Rückenteil hat eine glattere, bequemere Kurve und bietet standardmäßig und maximal eine größere Abdeckung.
+
+
+Stelle sicher, dass du die Optionen horizontale und vertikale Stoffdehnung an deinen Stoff anpasst. Wenn das Schnittmuster im Vergleich zu gekauften Unterhosen riesig aussieht, liegt das vermutlich daran, dass diese viel mehr gedehnt werden.
+
+
+
+ Umbra kann leicht als Badehose genäht werden. Verwende einfach einen Bademodenstoff und nähe, falls gewünscht, ein einmal umgeschlagenes Stück Stoff mit zwei Löchern als Kordelzug anstelle des Gummibandes am Bund an.
+
diff --git a/markdown/org/docs/designs/umbra/notes/en.md b/markdown/org/docs/designs/umbra/notes/en.md
new file mode 100644
index 00000000000..18f78044bd5
--- /dev/null
+++ b/markdown/org/docs/designs/umbra/notes/en.md
@@ -0,0 +1,31 @@
+---
+title: "Umbra undies: Designer Notes"
+---
+
+Umbra is a comfortable and flexible underwear briefs design that aims to be inclusive for as many people as possible.
+
+Umbra is based on some experiments, prototypes and measurements of my favourite underwear.
+
+Umbra is especially designed for diverse users. You can easily add several useful modifications, even if some of them are not directly supported by the software.
+
+Some features of Umbra are as follows:
+
+* It can be sewn so that no (potentially itchy) seam allowance touches the skin, which helps people with sensitive skin and those with autism. The crotch and side seams are placed on the inside between the front part layers and any elastics on the waist and leg openings can be put on the outside, if so desired.
+* It can be sewn with or without a bulge. You can even draft the design twice, and cut the front lining without bulge and the main fabric front part with one, and you'll be able to create a front pocket with plenty of space.
+* Rise, back exposure, front exposure and gusset width are controlled separately, so you can create e.g. very comfortable thongs with enough room in the front, or many other designs.
+
+Umbra is based on code from Uma by Natalia Sayang and Joost De Cock, but has been heavily modified in its construction and default style.
+Some key differences are:
+* Umbra doesn't have a separate gusset part and instead adds lining to the whole front piece.
+* The hip measurements are being taken into account to better determine the waistband size.
+* The height of the underwear is based on the usually more accurate Cross Seam measurement instead of the Waist to upper leg measurement.
+* The positions of the side and crotch seams can be adjusted freely, even with a bulge selected.
+* The back part has a smoother, more comfortable curve and provides greater coverage by default and at maximum.
+
+
+Be sure to adjust the "horizontal fabric stretch" and "vertical fabric stretch" options according to your fabric. The default stretch values are rather low. If your pattern appears huge compared to store-bought underwear, they probably use much more stretch.
+
+
+
+ If you wish to adapt Umbra to a swimwear bottom, it should be easy to do so. Simply use swimwear fabric and, if desired, sew on a folded over piece of fabric with two holes instead of a waistband elastic, to create a drawstring.
+
diff --git a/markdown/org/docs/designs/umbra/options/backdip/de.md b/markdown/org/docs/designs/umbra/options/backdip/de.md
new file mode 100644
index 00000000000..b502afb0292
--- /dev/null
+++ b/markdown/org/docs/designs/umbra/options/backdip/de.md
@@ -0,0 +1,7 @@
+---
+title: "Absenkung hintere Taille"
+---
+
+Diese Option bestimmt, wie sehr die Rückentaillenkurven (mehr oder weniger Haut) sind.
+
+
diff --git a/markdown/org/docs/designs/umbra/options/backdip/en.md b/markdown/org/docs/designs/umbra/options/backdip/en.md
new file mode 100644
index 00000000000..7df71462dd3
--- /dev/null
+++ b/markdown/org/docs/designs/umbra/options/backdip/en.md
@@ -0,0 +1,7 @@
+---
+title: "Back waist dip"
+---
+
+This option controls how much the back waist curves (revealing more or less skin).
+
+
diff --git a/markdown/org/docs/designs/umbra/options/backdip/es.md b/markdown/org/docs/designs/umbra/options/backdip/es.md
new file mode 100644
index 00000000000..75fe6a58224
--- /dev/null
+++ b/markdown/org/docs/designs/umbra/options/backdip/es.md
@@ -0,0 +1,7 @@
+---
+title: "Buceo de cintura trasera"
+---
+
+Esta opción controla hasta qué punto las curvas de la cintura trasera (revelando más o menos la piel).
+
+
diff --git a/markdown/org/docs/designs/umbra/options/backdip/fr.md b/markdown/org/docs/designs/umbra/options/backdip/fr.md
new file mode 100644
index 00000000000..3da5121528f
--- /dev/null
+++ b/markdown/org/docs/designs/umbra/options/backdip/fr.md
@@ -0,0 +1,7 @@
+---
+title: "Profondeur de la taille arrière"
+---
+
+Cette option permet de contrôler à quel point la taille arrière est courbée (révélant plus ou moins de peau).
+
+
diff --git a/markdown/org/docs/designs/umbra/options/backdip/nl.md b/markdown/org/docs/designs/umbra/options/backdip/nl.md
new file mode 100644
index 00000000000..3262e005d76
--- /dev/null
+++ b/markdown/org/docs/designs/umbra/options/backdip/nl.md
@@ -0,0 +1,7 @@
+---
+title: "Achterste dip taille"
+---
+
+Deze optie bepaalt hoeveel de omgekeerde golfcurves (min of meer skin) onthullen.
+
+
diff --git a/markdown/org/docs/designs/umbra/options/backdip/uk.md b/markdown/org/docs/designs/umbra/options/backdip/uk.md
new file mode 100644
index 00000000000..b0be35ed7eb
--- /dev/null
+++ b/markdown/org/docs/designs/umbra/options/backdip/uk.md
@@ -0,0 +1,7 @@
+---
+title: "Нахил спини до талії"
+---
+
+Ця опція контролює, наскільки сильно вигинається задня частина талії (відкриваючи більше або менше шкіри).
+
+
diff --git a/markdown/org/docs/designs/umbra/options/backdipshape/de.md b/markdown/org/docs/designs/umbra/options/backdipshape/de.md
new file mode 100644
index 00000000000..aa241efc67b
--- /dev/null
+++ b/markdown/org/docs/designs/umbra/options/backdipshape/de.md
@@ -0,0 +1,12 @@
+---
+title: "Verlauf der Rückentaillenkurve"
+---
+
+Diese Option steuert die Kurve der hinteren Taillenabsenkung. Diese Option wirkt sich nur aus, wenn die hintere Taillenabsenkung auf einen Wert ungleich Null eingestellt ist.
+
+Höhere Werte erzeugen eine flachere Kurve in der Mitte und eine stärkere Kurve um die Seitennaht.
+
+Niedrigere Werte erzeugen eine schärfere Kurve in der Mitte und eine sanftere Kurve um die Seitennaht.
+
+
+
diff --git a/markdown/org/docs/designs/umbra/options/backdipshape/en.md b/markdown/org/docs/designs/umbra/options/backdipshape/en.md
new file mode 100644
index 00000000000..7f8294d134a
--- /dev/null
+++ b/markdown/org/docs/designs/umbra/options/backdipshape/en.md
@@ -0,0 +1,11 @@
+---
+title: "Back waist dip shape"
+---
+
+This option controls the curve of the back waist dip. This option only has an effect if the back waist dip is set to a nonzero value.
+
+Higher values create a flatter curve at the center and increase the curve around the side seam.
+
+Lower values create a sharper curve at the center and a smoother curve around the side seam.
+
+
diff --git a/markdown/org/docs/designs/umbra/options/backexposure/de.md b/markdown/org/docs/designs/umbra/options/backexposure/de.md
new file mode 100644
index 00000000000..f5db103479e
--- /dev/null
+++ b/markdown/org/docs/designs/umbra/options/backexposure/de.md
@@ -0,0 +1,6 @@
+---
+title: "Hintere Freilegung"
+---
+
+Diese Option steuert die Menge der exponierten Haut auf der Rückseite.
+
diff --git a/markdown/org/docs/designs/umbra/options/backexposure/en.md b/markdown/org/docs/designs/umbra/options/backexposure/en.md
new file mode 100644
index 00000000000..56c4d602a90
--- /dev/null
+++ b/markdown/org/docs/designs/umbra/options/backexposure/en.md
@@ -0,0 +1,6 @@
+---
+title: "Back exposure"
+---
+
+This option controls the amount of exposed skin on the back.
+
diff --git a/markdown/org/docs/designs/umbra/options/backexposure/es.md b/markdown/org/docs/designs/umbra/options/backexposure/es.md
new file mode 100644
index 00000000000..da7e4275564
--- /dev/null
+++ b/markdown/org/docs/designs/umbra/options/backexposure/es.md
@@ -0,0 +1,6 @@
+---
+title: "Exposición trasera"
+---
+
+Esta opción controla la cantidad de piel expuesta en la espalda.
+
diff --git a/markdown/org/docs/designs/umbra/options/backexposure/fr.md b/markdown/org/docs/designs/umbra/options/backexposure/fr.md
new file mode 100644
index 00000000000..d800b1a4d49
--- /dev/null
+++ b/markdown/org/docs/designs/umbra/options/backexposure/fr.md
@@ -0,0 +1,6 @@
+---
+title: "Exposition des fesses"
+---
+
+Cette option permet de contrôler la quantité de peau exposée sur les fesses.
+
diff --git a/markdown/org/docs/designs/umbra/options/backexposure/nl.md b/markdown/org/docs/designs/umbra/options/backexposure/nl.md
new file mode 100644
index 00000000000..52e171df28d
--- /dev/null
+++ b/markdown/org/docs/designs/umbra/options/backexposure/nl.md
@@ -0,0 +1,6 @@
+---
+title: "Blootstelling rug"
+---
+
+Deze optie bepaalt de hoeveelheid blootgestelde huid op de achterkant.
+
diff --git a/markdown/org/docs/designs/umbra/options/backexposure/uk.md b/markdown/org/docs/designs/umbra/options/backexposure/uk.md
new file mode 100644
index 00000000000..c785bc0e371
--- /dev/null
+++ b/markdown/org/docs/designs/umbra/options/backexposure/uk.md
@@ -0,0 +1,6 @@
+---
+title: "Експозиція ззаду"
+---
+
+Ця опція контролює кількість відкритої шкіри на спині.
+
diff --git a/markdown/org/docs/designs/umbra/options/bulge/de.md b/markdown/org/docs/designs/umbra/options/bulge/de.md
new file mode 100644
index 00000000000..4f1a38efaea
--- /dev/null
+++ b/markdown/org/docs/designs/umbra/options/bulge/de.md
@@ -0,0 +1,5 @@
+---
+title: Wölbung
+---
+
+Diese Option steuert, wie viel zusätzlicher Platz vorne in der Unterhose geschaffen wird. Hat unter 2 Grad keine Auswirkung.
diff --git a/markdown/org/docs/designs/umbra/options/bulge/en.md b/markdown/org/docs/designs/umbra/options/bulge/en.md
new file mode 100644
index 00000000000..6308a10a54d
--- /dev/null
+++ b/markdown/org/docs/designs/umbra/options/bulge/en.md
@@ -0,0 +1,5 @@
+---
+title: Bulge
+---
+
+This option controls the extra room in the front of the underwear. Below 2 degrees, no extra bulge will be created.
diff --git a/markdown/org/docs/designs/umbra/options/bulgefullness/de.md b/markdown/org/docs/designs/umbra/options/bulgefullness/de.md
new file mode 100644
index 00000000000..32e6918589e
--- /dev/null
+++ b/markdown/org/docs/designs/umbra/options/bulgefullness/de.md
@@ -0,0 +1,5 @@
+---
+title: Wölbungs-Fülle
+---
+
+Diese Option steuert die Form der Wölbung. Große Werte führen zu einer runderen, größeren Wölbung, wobei das Nähen aber etwas schwerer werden kann.
diff --git a/markdown/org/docs/designs/umbra/options/bulgefullness/en.md b/markdown/org/docs/designs/umbra/options/bulgefullness/en.md
new file mode 100644
index 00000000000..66a8258b83a
--- /dev/null
+++ b/markdown/org/docs/designs/umbra/options/bulgefullness/en.md
@@ -0,0 +1,5 @@
+---
+title: Bulge fullness
+---
+
+This option controls the curve of the bulge, larger values lead to a more round, spacy bulge, but sewing might be more difficult.
diff --git a/markdown/org/docs/designs/umbra/options/de.md b/markdown/org/docs/designs/umbra/options/de.md
new file mode 100644
index 00000000000..c614f0dbe22
--- /dev/null
+++ b/markdown/org/docs/designs/umbra/options/de.md
@@ -0,0 +1,5 @@
+---
+title: "Umbra Unterhosen: Design Optionen"
+---
+
+
+
+ )
+}
+
+/*
+ * React component for the front
+ */
+export const UmbraFront = ({
+ className = 'w-64', // CSS classes to apply
+ stroke = 1, // Stroke width to use
+}) => {
+ // Normalize stroke across designs
+ stroke = stroke * strokeScale
+
+ return (
+
+
+ )
+}
+
+/*
+ * React component for the back
+ */
+export const UmbraBack = ({
+ className = 'w-64', // CSS classes to apply
+ stroke = 1, // Stroke width to use
+}) => {
+ // Normalize stroke across designs
+ stroke = stroke * strokeScale
+
+ return (
+
+
+ )
+}
+
+/*
+ * SVG elements for the front
+ */
+export const Front = ({ stroke }) => (
+ <>
+ 
+ 
+ 
+ 
+ 
+ 
+ 
+ 
+ 
+