@office-open/core 0.6.3 → 0.6.5

package/dist/drawingml-YMdpQfWs.mjs

@@ -0,0 +1,4155 @@
+import { a as BuilderElement, b as XmlComponent } from "./xml-components-CADgke8j.mjs";
+import hash from "hash.js";
+import { customAlphabet, nanoid } from "nanoid/non-secure";
+//#region src/converters.ts
+/**
+* OOXML unit conversion utilities.
+*
+* @module
+*/
+/**
+* Converts millimeters to TWIP (twentieths of a point).
+*/
+const convertMillimetersToTwip = (millimeters) => Math.floor(millimeters / 25.4 * 72 * 20);
+/**
+* Converts inches to TWIP (twentieths of a point).
+*/
+const convertInchesToTwip = (inches) => Math.floor(inches * 72 * 20);
+/**
+* Converts pixels to EMU (96 DPI).
+*/
+const convertPixelsToEmu = (pixels) => Math.round(pixels * 9525);
+/**
+* Converts EMU to pixels (96 DPI).
+*/
+const convertEmuToPixels = (emus) => Math.round(emus / 9525);
+/**
+* Converts inches to EMU.
+*/
+const convertInchesToEmu = (inches) => Math.round(inches * 914400);
+/**
+* Converts EMU to inches.
+*/
+const convertEmuToInches = (emus) => emus / 914400;
+/**
+* Converts points to EMU.
+*/
+const convertPointsToEmu = (points) => Math.round(points * 12700);
+/**
+* Converts EMU to points.
+*/
+const convertEmuToPoints = (emus) => emus / 12700;
+//#endregion
+//#region src/id-generators.ts
+/**
+* Unique ID generation utilities.
+*
+* @module
+*/
+/**
+* Creates a unique numeric ID generator with sequential numbering.
+*/
+const uniqueNumericIdCreator = (initial = 0) => {
+	let currentCount = initial;
+	return () => ++currentCount;
+};
+/**
+* Generates a unique lowercase alphanumeric ID using nanoid.
+*/
+const uniqueId = () => nanoid().toLowerCase();
+/**
+* Generates a SHA-1 hash of the provided data.
+*/
+const hashedId = (data) => hash.sha1().update(data instanceof ArrayBuffer ? new Uint8Array(data) : data).digest("hex");
+/**
+* Generates a random hexadecimal string of specified length.
+*/
+const generateUuidPart = (count) => customAlphabet("1234567890abcdef", count)();
+/**
+* Generates a UUID v4-style unique identifier.
+*/
+const uniqueUuid = () => `${generateUuidPart(8)}-${generateUuidPart(4)}-${generateUuidPart(4)}-${generateUuidPart(4)}-${generateUuidPart(12)}`;
+//#endregion
+//#region src/drawingml/color/color-transform.ts
+/**
+* Color transform elements for DrawingML colors.
+*
+* This module provides color transformation elements defined in EG_ColorTransform,
+* which can be applied as child elements to any color type (srgbClr, schemeClr, etc.).
+*
+* Reference: ISO/IEC 29500-4, dml-main.xsd, EG_ColorTransform
+*
+* @module
+*/
+/**
+* Creates color transform child elements.
+*
+* These elements modify the parent color according to OOXML color transform rules.
+* Multiple transforms can be applied in sequence.
+*
+* @example
+* ```typescript
+* // Lighten accent1 by 40%
+* createColorTransforms({ tint: 40000 });
+* // Semi-transparent red with 50% alpha
+* createColorTransforms({ alpha: 50000 });
+* ```
+*/
+const createColorTransforms = (options) => {
+	const transforms = [];
+	if (options.tint !== void 0) transforms.push(new BuilderElement({
+		attributes: { val: {
+			key: "val",
+			value: options.tint
+		} },
+		name: "a:tint"
+	}));
+	if (options.shade !== void 0) transforms.push(new BuilderElement({
+		attributes: { val: {
+			key: "val",
+			value: options.shade
+		} },
+		name: "a:shade"
+	}));
+	if (options.comp) transforms.push(new BuilderElement({ name: "a:comp" }));
+	if (options.inv) transforms.push(new BuilderElement({ name: "a:inv" }));
+	if (options.gray) transforms.push(new BuilderElement({ name: "a:gray" }));
+	if (options.alpha !== void 0) transforms.push(new BuilderElement({
+		attributes: { val: {
+			key: "val",
+			value: options.alpha
+		} },
+		name: "a:alpha"
+	}));
+	if (options.alphaOff !== void 0) transforms.push(new BuilderElement({
+		attributes: { val: {
+			key: "val",
+			value: options.alphaOff
+		} },
+		name: "a:alphaOff"
+	}));
+	if (options.alphaMod !== void 0) transforms.push(new BuilderElement({
+		attributes: { val: {
+			key: "val",
+			value: options.alphaMod
+		} },
+		name: "a:alphaMod"
+	}));
+	if (options.hue !== void 0) transforms.push(new BuilderElement({
+		attributes: { val: {
+			key: "val",
+			value: options.hue
+		} },
+		name: "a:hue"
+	}));
+	if (options.hueOff !== void 0) transforms.push(new BuilderElement({
+		attributes: { val: {
+			key: "val",
+			value: options.hueOff
+		} },
+		name: "a:hueOff"
+	}));
+	if (options.hueMod !== void 0) transforms.push(new BuilderElement({
+		attributes: { val: {
+			key: "val",
+			value: options.hueMod
+		} },
+		name: "a:hueMod"
+	}));
+	if (options.sat !== void 0) transforms.push(new BuilderElement({
+		attributes: { val: {
+			key: "val",
+			value: options.sat
+		} },
+		name: "a:sat"
+	}));
+	if (options.satOff !== void 0) transforms.push(new BuilderElement({
+		attributes: { val: {
+			key: "val",
+			value: options.satOff
+		} },
+		name: "a:satOff"
+	}));
+	if (options.satMod !== void 0) transforms.push(new BuilderElement({
+		attributes: { val: {
+			key: "val",
+			value: options.satMod
+		} },
+		name: "a:satMod"
+	}));
+	if (options.lum !== void 0) transforms.push(new BuilderElement({
+		attributes: { val: {
+			key: "val",
+			value: options.lum
+		} },
+		name: "a:lum"
+	}));
+	if (options.lumOff !== void 0) transforms.push(new BuilderElement({
+		attributes: { val: {
+			key: "val",
+			value: options.lumOff
+		} },
+		name: "a:lumOff"
+	}));
+	if (options.lumMod !== void 0) transforms.push(new BuilderElement({
+		attributes: { val: {
+			key: "val",
+			value: options.lumMod
+		} },
+		name: "a:lumMod"
+	}));
+	if (options.red !== void 0) transforms.push(new BuilderElement({
+		attributes: { val: {
+			key: "val",
+			value: options.red
+		} },
+		name: "a:red"
+	}));
+	if (options.redOff !== void 0) transforms.push(new BuilderElement({
+		attributes: { val: {
+			key: "val",
+			value: options.redOff
+		} },
+		name: "a:redOff"
+	}));
+	if (options.redMod !== void 0) transforms.push(new BuilderElement({
+		attributes: { val: {
+			key: "val",
+			value: options.redMod
+		} },
+		name: "a:redMod"
+	}));
+	if (options.green !== void 0) transforms.push(new BuilderElement({
+		attributes: { val: {
+			key: "val",
+			value: options.green
+		} },
+		name: "a:green"
+	}));
+	if (options.greenOff !== void 0) transforms.push(new BuilderElement({
+		attributes: { val: {
+			key: "val",
+			value: options.greenOff
+		} },
+		name: "a:greenOff"
+	}));
+	if (options.greenMod !== void 0) transforms.push(new BuilderElement({
+		attributes: { val: {
+			key: "val",
+			value: options.greenMod
+		} },
+		name: "a:greenMod"
+	}));
+	if (options.blue !== void 0) transforms.push(new BuilderElement({
+		attributes: { val: {
+			key: "val",
+			value: options.blue
+		} },
+		name: "a:blue"
+	}));
+	if (options.blueOff !== void 0) transforms.push(new BuilderElement({
+		attributes: { val: {
+			key: "val",
+			value: options.blueOff
+		} },
+		name: "a:blueOff"
+	}));
+	if (options.blueMod !== void 0) transforms.push(new BuilderElement({
+		attributes: { val: {
+			key: "val",
+			value: options.blueMod
+		} },
+		name: "a:blueMod"
+	}));
+	if (options.gamma) transforms.push(new BuilderElement({ name: "a:gamma" }));
+	if (options.invGamma) transforms.push(new BuilderElement({ name: "a:invGamma" }));
+	return transforms;
+};
+//#endregion
+//#region src/drawingml/color/hsl-color.ts
+/**
+* HSL color element for DrawingML.
+*
+* This module provides HSL (Hue, Saturation, Luminance) color support.
+*
+* Reference: ISO/IEC 29500-4, dml-main.xsd, CT_HslColor
+*
+* @module
+*/
+/**
+* Creates an HSL color element.
+*
+* Specifies a color using Hue, Saturation, and Luminance values.
+*
+* ## XSD Schema
+* ```xml
+* <xsd:complexType name="CT_HslColor">
+*   <xsd:sequence>
+*     <xsd:group ref="EG_ColorTransform" minOccurs="0" maxOccurs="unbounded"/>
+*   </xsd:sequence>
+*   <xsd:attribute name="hue" type="ST_PositiveFixedAngle" use="required"/>
+*   <xsd:attribute name="sat" type="ST_Percentage" use="required"/>
+*   <xsd:attribute name="lum" type="ST_Percentage" use="required"/>
+* </xsd:complexType>
+* ```
+*/
+const createHslColor = (options) => {
+	const transforms = options.transforms ? createColorTransforms(options.transforms) : [];
+	return new BuilderElement({
+		attributes: {
+			hue: {
+				key: "hue",
+				value: options.hue
+			},
+			lum: {
+				key: "lum",
+				value: options.luminance
+			},
+			sat: {
+				key: "sat",
+				value: options.saturation
+			}
+		},
+		children: [...transforms],
+		name: "a:hslClr"
+	});
+};
+//#endregion
+//#region src/drawingml/color/preset-color.ts
+/**
+* Preset color element for DrawingML.
+*
+* This module provides named preset colors (CSS named colors).
+*
+* Reference: ISO/IEC 29500-4, dml-main.xsd, CT_PresetColor / ST_PresetColorVal
+*
+* @module
+*/
+/**
+* Preset color values (CSS named colors).
+*
+* ## XSD Schema
+* ```xml
+* <xsd:simpleType name="ST_PresetColorVal">
+*   <xsd:restriction base="xsd:token">
+*     <xsd:enumeration value="aliceBlue"/>
+*     ...
+*     <xsd:enumeration value="yellowGreen"/>
+*   </xsd:restriction>
+* </xsd:simpleType>
+* ```
+*/
+const PresetColor = {
+	ALICE_BLUE: "aliceBlue",
+	ANTIQUE_WHITE: "antiqueWhite",
+	AQUA: "aqua",
+	AQUAMARINE: "aquamarine",
+	AZURE: "azure",
+	BEIGE: "beige",
+	BISQUE: "bisque",
+	BLACK: "black",
+	BLANCHED_ALMOND: "blanchedAlmond",
+	BLUE: "blue",
+	BLUE_VIOLET: "blueViolet",
+	BROWN: "brown",
+	BURLY_WOOD: "burlyWood",
+	CADET_BLUE: "cadetBlue",
+	CHARTREUSE: "chartreuse",
+	CHOCOLATE: "chocolate",
+	CORAL: "coral",
+	CORNFLOWER_BLUE: "cornflowerBlue",
+	CORNSILK: "cornsilk",
+	CRIMSON: "crimson",
+	CYAN: "cyan",
+	DARK_BLUE: "darkBlue",
+	DARK_CYAN: "darkCyan",
+	DARK_GOLDENROD: "darkGoldenrod",
+	DARK_GRAY: "darkGray",
+	DARK_GREY: "darkGrey",
+	DARK_GREEN: "darkGreen",
+	DARK_KHAKI: "darkKhaki",
+	DARK_MAGENTA: "darkMagenta",
+	DARK_OLIVE_GREEN: "darkOliveGreen",
+	DARK_ORANGE: "darkOrange",
+	DARK_ORCHID: "darkOrchid",
+	DARK_RED: "darkRed",
+	DARK_SALMON: "darkSalmon",
+	DARK_SEA_GREEN: "darkSeaGreen",
+	DARK_SLATE_BLUE: "darkSlateBlue",
+	DARK_SLATE_GRAY: "darkSlateGray",
+	DARK_SLATE_GREY: "darkSlateGrey",
+	DARK_TURQUOISE: "darkTurquoise",
+	DARK_VIOLET: "darkViolet",
+	DEEP_PINK: "deepPink",
+	DEEP_SKY_BLUE: "deepSkyBlue",
+	DIM_GRAY: "dimGray",
+	DIM_GREY: "dimGrey",
+	DODGER_BLUE: "dodgerBlue",
+	FIREBRICK: "firebrick",
+	FLORAL_WHITE: "floralWhite",
+	FOREST_GREEN: "forestGreen",
+	FUCHSIA: "fuchsia",
+	GAINSBORO: "gainsboro",
+	GHOST_WHITE: "ghostWhite",
+	GOLD: "gold",
+	GOLDENROD: "goldenrod",
+	GRAY: "gray",
+	GREY: "grey",
+	GREEN: "green",
+	GREEN_YELLOW: "greenYellow",
+	HONEYDEW: "honeydew",
+	HOT_PINK: "hotPink",
+	INDIAN_RED: "indianRed",
+	INDIGO: "indigo",
+	IVORY: "ivory",
+	KHAKI: "khaki",
+	LAVENDER: "lavender",
+	LAVENDER_BLUSH: "lavenderBlush",
+	LAWN_GREEN: "lawnGreen",
+	LEMON_CHIFFON: "lemonChiffon",
+	LIGHT_BLUE: "lightBlue",
+	LIGHT_CORAL: "lightCoral",
+	LIGHT_CYAN: "lightCyan",
+	LIGHT_GOLDENROD_YELLOW: "lightGoldenrodYellow",
+	LIGHT_GRAY: "lightGray",
+	LIGHT_GREY: "lightGrey",
+	LIGHT_GREEN: "lightGreen",
+	LIGHT_PINK: "lightPink",
+	LIGHT_SALMON: "lightSalmon",
+	LIGHT_SEA_GREEN: "lightSeaGreen",
+	LIGHT_SKY_BLUE: "lightSkyBlue",
+	LIGHT_SLATE_GRAY: "lightSlateGray",
+	LIGHT_SLATE_GREY: "lightSlateGrey",
+	LIGHT_STEEL_BLUE: "lightSteelBlue",
+	LIGHT_YELLOW: "lightYellow",
+	LIME: "lime",
+	LIME_GREEN: "limeGreen",
+	LINEN: "linen",
+	MAGENTA: "magenta",
+	MAROON: "maroon",
+	MEDIUM_AQUAMARINE: "mediumAquamarine",
+	MEDIUM_BLUE: "mediumBlue",
+	MEDIUM_ORCHID: "mediumOrchid",
+	MEDIUM_PURPLE: "mediumPurple",
+	MEDIUM_SEA_GREEN: "mediumSeaGreen",
+	MEDIUM_SLATE_BLUE: "mediumSlateBlue",
+	MEDIUM_SPRING_GREEN: "mediumSpringGreen",
+	MEDIUM_TURQUOISE: "mediumTurquoise",
+	MEDIUM_VIOLET_RED: "mediumVioletRed",
+	MIDNIGHT_BLUE: "midnightBlue",
+	MINT_CREAM: "mintCream",
+	MISTY_ROSE: "mistyRose",
+	MOCCASIN: "moccasin",
+	NAVAJO_WHITE: "navajoWhite",
+	NAVY: "navy",
+	OLD_LACE: "oldLace",
+	OLIVE: "olive",
+	OLIVE_DRAB: "oliveDrab",
+	ORANGE: "orange",
+	ORANGE_RED: "orangeRed",
+	ORCHID: "orchid",
+	PALE_GOLDENROD: "paleGoldenrod",
+	PALE_GREEN: "paleGreen",
+	PALE_TURQUOISE: "paleTurquoise",
+	PALE_VIOLET_RED: "paleVioletRed",
+	PAPAYA_WHIP: "papayaWhip",
+	PEACH_PUFF: "peachPuff",
+	PERU: "peru",
+	PINK: "pink",
+	PLUM: "plum",
+	POWDER_BLUE: "powderBlue",
+	PURPLE: "purple",
+	RED: "red",
+	ROSY_BROWN: "rosyBrown",
+	ROYAL_BLUE: "royalBlue",
+	SADDLE_BROWN: "saddleBrown",
+	SALMON: "salmon",
+	SANDY_BROWN: "sandyBrown",
+	SEA_GREEN: "seaGreen",
+	SEA_SHELL: "seaShell",
+	SIENNA: "sienna",
+	SILVER: "silver",
+	SKY_BLUE: "skyBlue",
+	SLATE_BLUE: "slateBlue",
+	SLATE_GRAY: "slateGray",
+	SLATE_GREY: "slateGrey",
+	SNOW: "snow",
+	SPRING_GREEN: "springGreen",
+	STEEL_BLUE: "steelBlue",
+	TAN: "tan",
+	TEAL: "teal",
+	THISTLE: "thistle",
+	TOMATO: "tomato",
+	TURQUOISE: "turquoise",
+	VIOLET: "violet",
+	WHEAT: "wheat",
+	WHITE: "white",
+	WHITE_SMOKE: "whiteSmoke",
+	YELLOW: "yellow",
+	YELLOW_GREEN: "yellowGreen"
+};
+/**
+* Creates a preset color element.
+*
+* Specifies a color using a named preset (CSS named color).
+*
+* ## XSD Schema
+* ```xml
+* <xsd:complexType name="CT_PresetColor">
+*   <xsd:sequence>
+*     <xsd:group ref="EG_ColorTransform" minOccurs="0" maxOccurs="unbounded"/>
+*   </xsd:sequence>
+*   <xsd:attribute name="val" type="ST_PresetColorVal" use="required"/>
+* </xsd:complexType>
+* ```
+*/
+const createPresetColor = (options) => {
+	const transforms = options.transforms ? createColorTransforms(options.transforms) : [];
+	return new BuilderElement({
+		attributes: { value: {
+			key: "val",
+			value: options.value
+		} },
+		children: [...transforms],
+		name: "a:prstClr"
+	});
+};
+//#endregion
+//#region src/drawingml/color/rgb-color.ts
+/**
+* RGB color element for DrawingML shapes.
+*
+* This module provides RGB color support for solid fills.
+*
+* Reference: ISO/IEC 29500-4, dml-main.xsd, CT_SRgbColor
+*
+* @module
+*/
+/**
+* Creates an sRGB color element.
+*
+* Specifies a color using RGB hex values.
+*
+* ## XSD Schema
+* ```xml
+* <xsd:complexType name="CT_SRgbColor">
+*   <xsd:sequence>
+*     <xsd:group ref="EG_ColorTransform" minOccurs="0" maxOccurs="unbounded"/>
+*   </xsd:sequence>
+*   <xsd:attribute name="val" type="s:ST_HexColorRGB" use="required"/>
+* </xsd:complexType>
+* ```
+*
+* @example
+* ```typescript
+* const redColor = createRgbColor({ value: "FF0000" });
+* // With alpha transform
+* const semiRed = createRgbColor({ value: "FF0000", transforms: { alpha: 50000 } });
+* ```
+*/
+const createRgbColor = (options) => {
+	const transforms = options.transforms ? createColorTransforms(options.transforms) : [];
+	return new BuilderElement({
+		attributes: { value: {
+			key: "val",
+			value: options.value
+		} },
+		children: [...transforms],
+		name: "a:srgbClr"
+	});
+};
+//#endregion
+//#region src/drawingml/color/sc-rgb-color.ts
+/**
+* ScRGB color element for DrawingML shapes.
+*
+* This module provides scRGB color support using percentage-based RGB values.
+*
+* Reference: ISO/IEC 29500-4, dml-main.xsd, CT_ScRgbColor
+*
+* @module
+*/
+/**
+* Creates an scRGB color element.
+*
+* Specifies a color using percentage-based RGB values.
+*
+* ## XSD Schema
+* ```xml
+* <xsd:complexType name="CT_ScRgbColor">
+*   <xsd:sequence>
+*     <xsd:group ref="EG_ColorTransform" minOccurs="0" maxOccurs="unbounded"/>
+*   </xsd:sequence>
+*   <xsd:attribute name="r" type="ST_Percentage" use="required"/>
+*   <xsd:attribute name="g" type="ST_Percentage" use="required"/>
+*   <xsd:attribute name="b" type="ST_Percentage" use="required"/>
+* </xsd:complexType>
+* ```
+*
+* @example
+* ```typescript
+* const redColor = createScRgbColor({ r: "100%", g: "0%", b: "0%" });
+* // With alpha transform
+* const semiRed = createScRgbColor({ r: "100%", g: "0%", b: "0%", transforms: { alpha: 50000 } });
+* ```
+*/
+const createScRgbColor = (options) => {
+	const transforms = options.transforms ? createColorTransforms(options.transforms) : [];
+	return new BuilderElement({
+		attributes: {
+			r: {
+				key: "r",
+				value: options.r
+			},
+			g: {
+				key: "g",
+				value: options.g
+			},
+			b: {
+				key: "b",
+				value: options.b
+			}
+		},
+		children: [...transforms],
+		name: "a:scrgbClr"
+	});
+};
+//#endregion
+//#region src/drawingml/color/scheme-color.ts
+/**
+* Scheme color element for DrawingML shapes.
+*
+* This module provides scheme-based color support for solid fills,
+* allowing colors to be defined using theme color schemes.
+*
+* Reference: ISO/IEC 29500-4, dml-main.xsd, CT_SchemeColor / ST_SchemeColorVal
+*
+* @module
+*/
+/**
+* Scheme color values for theme-based colors.
+*
+* These values reference colors defined in the document's color scheme/theme.
+*/
+const SchemeColor = {
+	/** Background color 1 */
+	BG1: "bg1",
+	/** Text color 1 */
+	TX1: "tx1",
+	/** Background color 2 */
+	BG2: "bg2",
+	/** Text color 2 */
+	TX2: "tx2",
+	/** Accent color 1 */
+	ACCENT1: "accent1",
+	/** Accent color 2 */
+	ACCENT2: "accent2",
+	/** Accent color 3 */
+	ACCENT3: "accent3",
+	/** Accent color 4 */
+	ACCENT4: "accent4",
+	/** Accent color 5 */
+	ACCENT5: "accent5",
+	/** Accent color 6 */
+	ACCENT6: "accent6",
+	/** Hyperlink color */
+	HLINK: "hlink",
+	/** Followed hyperlink color */
+	FOLHLINK: "folHlink",
+	/** Dark color 1 */
+	DK1: "dk1",
+	/** Light color 1 */
+	LT1: "lt1",
+	/** Dark color 2 */
+	DK2: "dk2",
+	/** Light color 2 */
+	LT2: "lt2",
+	/** Placeholder color */
+	PHCLR: "phClr"
+};
+/**
+* Creates a scheme color element.
+*
+* Specifies a color using a theme color scheme reference.
+*
+* ## XSD Schema
+* ```xml
+* <xsd:complexType name="CT_SchemeColor">
+*   <xsd:sequence>
+*     <xsd:group ref="EG_ColorTransform" minOccurs="0" maxOccurs="unbounded"/>
+*   </xsd:sequence>
+*   <xsd:attribute name="val" type="ST_SchemeColorVal" use="required"/>
+* </xsd:complexType>
+* ```
+*
+* @example
+* ```typescript
+* const accentColor = createSchemeColor({ value: SchemeColor.ACCENT1 });
+* // With tint transform
+* const lightAccent = createSchemeColor({
+*   value: SchemeColor.ACCENT1,
+*   transforms: { tint: 40000 },
+* });
+* ```
+*/
+const createSchemeColor = (options) => {
+	const transforms = options.transforms ? createColorTransforms(options.transforms) : [];
+	return new BuilderElement({
+		attributes: { value: {
+			key: "val",
+			value: options.value
+		} },
+		children: [...transforms],
+		name: "a:schemeClr"
+	});
+};
+//#endregion
+//#region src/drawingml/color/system-color.ts
+/**
+* System color element for DrawingML.
+*
+* This module provides system color support, referencing OS-level UI colors.
+*
+* Reference: ISO/IEC 29500-4, dml-main.xsd, CT_SystemColor / ST_SystemColorVal
+*
+* @module
+*/
+/**
+* System color values referencing OS UI colors.
+*
+* ## XSD Schema
+* ```xml
+* <xsd:simpleType name="ST_SystemColorVal">
+*   <xsd:restriction base="xsd:token">
+*     <xsd:enumeration value="scrollBar"/>
+*     <xsd:enumeration value="background"/>
+*     ...
+*     <xsd:enumeration value="menuBar"/>
+*   </xsd:restriction>
+* </xsd:simpleType>
+* ```
+*/
+const SystemColor = {
+	SCROLL_BAR: "scrollBar",
+	BACKGROUND: "background",
+	ACTIVE_CAPTION: "activeCaption",
+	INACTIVE_CAPTION: "inactiveCaption",
+	MENU: "menu",
+	WINDOW: "window",
+	WINDOW_FRAME: "windowFrame",
+	MENU_TEXT: "menuText",
+	WINDOW_TEXT: "windowText",
+	CAPTION_TEXT: "captionText",
+	ACTIVE_BORDER: "activeBorder",
+	INACTIVE_BORDER: "inactiveBorder",
+	APP_WORKSPACE: "appWorkspace",
+	HIGHLIGHT: "highlight",
+	HIGHLIGHT_TEXT: "highlightText",
+	BTN_FACE: "btnFace",
+	BTN_SHADOW: "btnShadow",
+	GRAY_TEXT: "grayText",
+	BTN_TEXT: "btnText",
+	INACTIVE_CAPTION_TEXT: "inactiveCaptionText",
+	BTN_HIGHLIGHT: "btnHighlight",
+	THREE_D_DK_SHADOW: "3dDkShadow",
+	THREE_D_LIGHT: "3dLight",
+	INFO_TEXT: "infoText",
+	INFO_BK: "infoBk",
+	HOT_LIGHT: "hotLight",
+	GRADIENT_ACTIVE_CAPTION: "gradientActiveCaption",
+	GRADIENT_INACTIVE_CAPTION: "gradientInactiveCaption",
+	MENU_HIGHLIGHT: "menuHighlight",
+	MENU_BAR: "menuBar"
+};
+/**
+* Creates a system color element.
+*
+* References a system-defined UI color (e.g., window background, button face).
+*
+* ## XSD Schema
+* ```xml
+* <xsd:complexType name="CT_SystemColor">
+*   <xsd:sequence>
+*     <xsd:group ref="EG_ColorTransform" minOccurs="0" maxOccurs="unbounded"/>
+*   </xsd:sequence>
+*   <xsd:attribute name="val" type="ST_SystemColorVal" use="required"/>
+*   <xsd:attribute name="lastClr" type="s:ST_HexColorRGB" use="optional"/>
+* </xsd:complexType>
+* ```
+*/
+const createSystemColor = (options) => {
+	const transforms = options.transforms ? createColorTransforms(options.transforms) : [];
+	return new BuilderElement({
+		attributes: {
+			lastClr: {
+				key: "lastClr",
+				value: options.lastClr
+			},
+			value: {
+				key: "val",
+				value: options.value
+			}
+		},
+		children: [...transforms],
+		name: "a:sysClr"
+	});
+};
+//#endregion
+//#region src/drawingml/color/solid-fill.ts
+/**
+* Solid fill element for DrawingML shapes.
+*
+* This module provides solid fill support for outlines and shapes,
+* supporting RGB, scheme, HSL, system, and preset colors.
+*
+* Reference: ISO/IEC 29500-4, dml-main.xsd, CT_SolidColorFillProperties
+*
+* @module
+*/
+/**
+* Creates the color child element for a solid fill based on the color type.
+*/
+const SYSTEM_COLOR_VALUES = new Set(Object.values(SystemColor));
+const PRESET_COLOR_VALUES = new Set(Object.values(PresetColor));
+const SCHEME_COLOR_VALUES = new Set(Object.values(SchemeColor));
+const createColorElement = (color) => {
+	if ("hue" in color && "saturation" in color && "luminance" in color) return createHslColor(color);
+	if ("r" in color && "g" in color && "b" in color) return createScRgbColor(color);
+	const colorValue = color.value;
+	if (SYSTEM_COLOR_VALUES.has(colorValue)) return createSystemColor(color);
+	if (PRESET_COLOR_VALUES.has(colorValue)) return createPresetColor(color);
+	if (SCHEME_COLOR_VALUES.has(colorValue)) return createSchemeColor(color);
+	return createRgbColor(color);
+};
+/**
+* Creates a solid fill element.
+*
+* Specifies a solid color fill using any supported color type.
+*
+* ## XSD Schema
+* ```xml
+* <xsd:complexType name="CT_SolidColorFillProperties">
+*   <xsd:sequence>
+*     <xsd:group ref="EG_ColorChoice" minOccurs="0"/>
+*     <xsd:group ref="EG_EffectProperties" minOccurs="0"/>
+*   </xsd:sequence>
+* </xsd:complexType>
+* ```
+*
+* @example
+* ```typescript
+* // RGB solid fill
+* const fill = createSolidFill({ value: "FF0000" });
+* // Scheme solid fill with tint
+* const schemeFill = createSolidFill({
+*   value: SchemeColor.ACCENT1, transforms: { tint: 40000 },
+* });
+* // HSL solid fill
+* const hslFill = createSolidFill({ hue: 120000, saturation: 100000, luminance: 50000 });
+* ```
+*/
+const createSolidFill = (options) => new BuilderElement({
+	children: [createColorElement(options)],
+	name: "a:solidFill"
+});
+//#endregion
+//#region src/drawingml/blip/blip-effects.ts
+/**
+* Blip image adjustment effects for DrawingML.
+*
+* These effects are applied directly to the image data within the `<a:blip>` element,
+* corresponding to Word's "Picture Format > Adjust" features (brightness, contrast,
+* grayscale, tint, duotone, etc.).
+*
+* Reference: ISO/IEC 29500-4, dml-main.xsd, CT_Blip children
+*
+* @module
+*/
+/**
+* Creates blip effect elements from BlipEffectsOptions.
+*
+* @returns Array of XML components representing blip effects
+*/
+const createBlipEffects = (options) => {
+	const children = [];
+	if (options.grayscale) children.push(new BuilderElement({ name: "a:grayscl" }));
+	if (options.luminance) {
+		const attrs = {};
+		if (options.luminance.bright !== void 0) attrs.bright = {
+			key: "bright",
+			value: `${options.luminance.bright}%`
+		};
+		if (options.luminance.contrast !== void 0) attrs.contrast = {
+			key: "contrast",
+			value: `${options.luminance.contrast}%`
+		};
+		children.push(new BuilderElement({
+			attributes: attrs,
+			name: "a:lum"
+		}));
+	}
+	if (options.hsl) {
+		const attrs = {};
+		if (options.hsl.hue !== void 0) attrs.hue = {
+			key: "hue",
+			value: String(options.hsl.hue)
+		};
+		if (options.hsl.saturation !== void 0) attrs.sat = {
+			key: "sat",
+			value: `${options.hsl.saturation}%`
+		};
+		if (options.hsl.luminance !== void 0) attrs.lum = {
+			key: "lum",
+			value: `${options.hsl.luminance}%`
+		};
+		children.push(new BuilderElement({
+			attributes: attrs,
+			name: "a:hsl"
+		}));
+	}
+	if (options.tint) {
+		const attrs = {};
+		if (options.tint.hue !== void 0) attrs.hue = {
+			key: "hue",
+			value: String(options.tint.hue)
+		};
+		if (options.tint.amount !== void 0) attrs.amt = {
+			key: "amt",
+			value: `${options.tint.amount}%`
+		};
+		children.push(new BuilderElement({
+			attributes: attrs,
+			name: "a:tint"
+		}));
+	}
+	if (options.duotone) children.push(new BuilderElement({
+		children: [createColorElement(options.duotone.color1), createColorElement(options.duotone.color2)],
+		name: "a:duotone"
+	}));
+	if (options.biLevel) children.push(new BuilderElement({
+		attributes: { thresh: {
+			key: "thresh",
+			value: `${options.biLevel.threshold}%`
+		} },
+		name: "a:biLevel"
+	}));
+	if (options.alphaCeiling) children.push(new BuilderElement({ name: "a:alphaCeiling" }));
+	if (options.alphaFloor) children.push(new BuilderElement({ name: "a:alphaFloor" }));
+	if (options.alphaInverse !== void 0) if (typeof options.alphaInverse === "boolean") children.push(new BuilderElement({ name: "a:alphaInv" }));
+	else children.push(new BuilderElement({
+		children: [createColorElement(options.alphaInverse)],
+		name: "a:alphaInv"
+	}));
+	if (options.alphaModFix) {
+		const amt = options.alphaModFix.amount ?? 100;
+		children.push(new BuilderElement({
+			attributes: { amt: {
+				key: "amt",
+				value: `${amt}%`
+			} },
+			name: "a:alphaModFix"
+		}));
+	}
+	if (options.alphaRepl) children.push(new BuilderElement({
+		attributes: { a: {
+			key: "a",
+			value: `${options.alphaRepl.amount}%`
+		} },
+		name: "a:alphaRepl"
+	}));
+	if (options.alphaBiLevel) children.push(new BuilderElement({
+		attributes: { thresh: {
+			key: "thresh",
+			value: `${options.alphaBiLevel.threshold}%`
+		} },
+		name: "a:alphaBiLevel"
+	}));
+	if (options.colorChange) {
+		const attrs = {};
+		if (options.colorChange.useAlpha === false) attrs.useA = {
+			key: "useA",
+			value: "0"
+		};
+		children.push(new BuilderElement({
+			attributes: attrs,
+			children: [new BuilderElement({
+				children: [createColorElement(options.colorChange.from)],
+				name: "a:clrFrom"
+			}), new BuilderElement({
+				children: [createColorElement(options.colorChange.to)],
+				name: "a:clrTo"
+			})],
+			name: "a:clrChange"
+		}));
+	}
+	if (options.colorRepl) children.push(new BuilderElement({
+		children: [createColorElement(options.colorRepl.color)],
+		name: "a:clrRepl"
+	}));
+	if (options.blur) {
+		const attrs = {};
+		if (options.blur.radius !== void 0) attrs.rad = {
+			key: "rad",
+			value: options.blur.radius
+		};
+		if (options.blur.grow === false) attrs.grow = {
+			key: "grow",
+			value: 0
+		};
+		children.push(new BuilderElement({
+			attributes: attrs,
+			name: "a:blur"
+		}));
+	}
+	return children;
+};
+//#endregion
+//#region src/drawingml/blip/source-rectangle.ts
+/**
+* Source rectangle module for blip fills.
+*
+* This module defines the portion of an image to use when filling a shape.
+*
+* Reference: ISO/IEC 29500-4, dml-main.xsd, CT_RelativeRect
+*
+* @module
+*/
+/**
+* Creates a source rectangle element for blip fill cropping.
+*
+* This element specifies a portion of the blip (image) to use as the fill.
+* When no options are provided, the entire blip is used.
+*
+* Reference: ISO/IEC 29500-4, dml-main.xsd, CT_RelativeRect
+*
+* ## XSD Schema
+* ```xml
+* <xsd:complexType name="CT_RelativeRect">
+*   <xsd:attribute name="l" type="ST_Percentage" use="optional" default="0"/>
+*   <xsd:attribute name="t" type="ST_Percentage" use="optional" default="0"/>
+*   <xsd:attribute name="r" type="ST_Percentage" use="optional" default="0"/>
+*   <xsd:attribute name="b" type="ST_Percentage" use="optional" default="0"/>
+* </xsd:complexType>
+* ```
+*
+* @example
+* ```typescript
+* // Crop 10% from left and right
+* createSourceRectangle({ left: 10000, right: 10000 });
+* ```
+*/
+const createSourceRectangle = (options) => {
+	if (!options) return new BuilderElement({ name: "a:srcRect" });
+	const attributes = {};
+	if (options.left !== void 0) attributes.l = {
+		key: "l",
+		value: options.left
+	};
+	if (options.top !== void 0) attributes.t = {
+		key: "t",
+		value: options.top
+	};
+	if (options.right !== void 0) attributes.r = {
+		key: "r",
+		value: options.right
+	};
+	if (options.bottom !== void 0) attributes.b = {
+		key: "b",
+		value: options.bottom
+	};
+	return new BuilderElement({
+		attributes,
+		name: "a:srcRect"
+	});
+};
+//#endregion
+//#region src/drawingml/blip/stretch.ts
+/**
+* Stretch fill module for blip fills.
+*
+* This module defines how images are stretched to fill shapes.
+*
+* Reference: http://officeopenxml.com/drwPic.php
+*
+* @module
+*/
+/**
+* Represents a fill rectangle for stretch fill mode.
+*
+* This element specifies the rectangular area of the shape to which
+* the blip fill should be stretched.
+*
+* Reference: http://officeopenxml.com/drwPic.php
+*
+* ## XSD Schema
+* ```xml
+* <xsd:complexType name="CT_RelativeRect">
+*   <xsd:attribute name="l" type="ST_Percentage" use="optional" default="0"/>
+*   <xsd:attribute name="t" type="ST_Percentage" use="optional" default="0"/>
+*   <xsd:attribute name="r" type="ST_Percentage" use="optional" default="0"/>
+*   <xsd:attribute name="b" type="ST_Percentage" use="optional" default="0"/>
+* </xsd:complexType>
+* ```
+*/
+var FillRectangle = class extends XmlComponent {
+	constructor() {
+		super("a:fillRect");
+	}
+};
+/**
+* Represents a stretch fill mode for blip fills.
+*
+* This element specifies that the blip (image) should be stretched to fill
+* the entire shape. The stretch fill is one of the fill mode properties
+* that determines how an image is applied to a shape.
+*
+* Reference: http://officeopenxml.com/drwPic.php
+*
+* ## XSD Schema
+* ```xml
+* <xsd:complexType name="CT_StretchInfoProperties">
+*   <xsd:sequence>
+*     <xsd:element name="fillRect" type="CT_RelativeRect" minOccurs="0" maxOccurs="1"/>
+*   </xsd:sequence>
+* </xsd:complexType>
+* ```
+*
+* @example
+* ```typescript
+* const stretch = new Stretch();
+* ```
+*/
+var Stretch = class extends XmlComponent {
+	constructor() {
+		super("a:stretch");
+		this.root.push(new FillRectangle());
+	}
+};
+//#endregion
+//#region src/xsd-mappings.ts
+/**
+* Bidirectional mappings between user-friendly values and XSD abbreviated values.
+*
+* When XSD uses full English words (e.g. "center", "start"), values are used directly — no mapping needed.
+* When XSD uses abbreviations (e.g. "ctr", "l", "rnd"), this module maps them to full words.
+*
+* Usage in generation (Options → XML):  xsdAlign.to("center") → "ctr"
+* Usage in parsing    (XML → Options):  xsdAlign.from("ctr")  → "center"
+*/
+/** Invert a Record<K, V> into Record<V, K>. */
+function invertMap(map) {
+	const result = {};
+	for (const key in map) result[map[key]] = key;
+	return result;
+}
+/** Create a bidirectional mapping helper from a single forward map. */
+function bidi(forward) {
+	const reverse = invertMap(forward);
+	return {
+		/** User-friendly value → XSD value */
+		to: (key) => forward[key] ?? key,
+		/** XSD value → user-friendly value */
+		from: (xsd) => reverse[xsd] ?? xsd,
+		/** The forward map (user → XSD) */
+		forward,
+		/** The reverse map (XSD → user) */
+		reverse
+	};
+}
+const xsdRectAlignment = bidi({
+	topLeft: "tl",
+	top: "t",
+	topRight: "tr",
+	left: "l",
+	center: "ctr",
+	right: "r",
+	bottomLeft: "bl",
+	bottom: "b",
+	bottomRight: "br"
+});
+const xsdTextAlign = bidi({
+	left: "l",
+	center: "ctr",
+	right: "r",
+	justify: "just"
+});
+const xsdTextAnchor = bidi({
+	top: "t",
+	center: "ctr",
+	bottom: "b"
+});
+const xsdLineCap = bidi({
+	round: "rnd",
+	square: "sq",
+	flat: "flat"
+});
+const xsdCompoundLine = bidi({
+	single: "sng",
+	double: "dbl",
+	thickThin: "thickThin",
+	thinThick: "thinThick",
+	triple: "tri"
+});
+const xsdPenAlignment = bidi({
+	center: "ctr",
+	inside: "in"
+});
+const xsdLineEndSize = bidi({
+	small: "sm",
+	medium: "med",
+	large: "lg"
+});
+const xsdBlendMode = bidi({
+	over: "over",
+	multiply: "mult",
+	screen: "screen",
+	darken: "darken",
+	lighten: "lighten"
+});
+const xsdPathFillMode = bidi({
+	none: "none",
+	normal: "norm",
+	lighten: "lighten",
+	lightenLess: "lightenLess",
+	darken: "darken",
+	darkenLess: "darkenLess"
+});
+const xsdEffectContainer = bidi({
+	sibling: "sib",
+	tree: "tree"
+});
+const xsdPresetShadow = bidi({
+	shadow1: "shdw1",
+	shadow2: "shdw2",
+	shadow3: "shdw3",
+	shadow4: "shdw4",
+	shadow5: "shdw5",
+	shadow6: "shdw6",
+	shadow7: "shdw7",
+	shadow8: "shdw8",
+	shadow9: "shdw9",
+	shadow10: "shdw10",
+	shadow11: "shdw11",
+	shadow12: "shdw12",
+	shadow13: "shdw13",
+	shadow14: "shdw14",
+	shadow15: "shdw15",
+	shadow16: "shdw16",
+	shadow17: "shdw17",
+	shadow18: "shdw18",
+	shadow19: "shdw19",
+	shadow20: "shdw20"
+});
+const xsdMaterialType = bidi({
+	legacyMatte: "legacyMatte",
+	legacyPlastic: "legacyPlastic",
+	legacyMetal: "legacyMetal",
+	legacyWireframe: "legacyWireframe",
+	matte: "matte",
+	plastic: "plastic",
+	metal: "metal",
+	warmMatte: "warmMatte",
+	translucentPowder: "translucentPowder",
+	powder: "powder",
+	darkEdge: "dkEdge",
+	softEdge: "softEdge",
+	clear: "clear",
+	flat: "flat",
+	softMetal: "softmetal"
+});
+const xsdPattern = bidi({
+	percent5: "pct5",
+	percent10: "pct10",
+	percent20: "pct20",
+	percent25: "pct25",
+	percent30: "pct30",
+	percent40: "pct40",
+	percent50: "pct50",
+	percent60: "pct60",
+	percent70: "pct70",
+	percent75: "pct75",
+	percent80: "pct80",
+	percent90: "pct90",
+	horizontal: "horz",
+	vertical: "vert",
+	lightHorizontal: "ltHorz",
+	lightVertical: "ltVert",
+	darkHorizontal: "dkHorz",
+	darkVertical: "dkVert",
+	narrowHorizontal: "narHorz",
+	narrowVertical: "narVert",
+	dashedHorizontal: "dashHorz",
+	dashedVertical: "dashVert",
+	cross: "cross",
+	downDiagonal: "dnDiag",
+	upDiagonal: "upDiag",
+	lightDownDiagonal: "ltDnDiag",
+	lightUpDiagonal: "ltUpDiag",
+	darkDownDiagonal: "dkDnDiag",
+	darkUpDiagonal: "dkUpDiag",
+	wideDownDiagonal: "wdDnDiag",
+	wideUpDiagonal: "wdUpDiag",
+	dashedDownDiagonal: "dashDnDiag",
+	dashedUpDiagonal: "dashUpDiag",
+	diagonalCross: "diagCross",
+	smallChecker: "smCheck",
+	largeChecker: "lgCheck",
+	smallGrid: "smGrid",
+	largeGrid: "lgGrid",
+	dotGrid: "dotGrid",
+	smallConfetti: "smConfetti",
+	largeConfetti: "lgConfetti",
+	horizontalBrick: "horzBrick",
+	diagonalBrick: "diagBrick",
+	solidDiamond: "solidDmnd",
+	openDiamond: "openDmnd",
+	dottedDiamond: "dotDmnd",
+	plaid: "plaid",
+	sphere: "sphere",
+	weave: "weave",
+	divot: "divot",
+	shingle: "shingle",
+	wave: "wave",
+	trellis: "trellis",
+	zigZag: "zigZag"
+});
+const xsdVerticalMergeRev = bidi({
+	continue: "cont",
+	restart: "rest"
+});
+const xsdUnderlineStyle = bidi({
+	single: "sng",
+	double: "dbl",
+	none: "none"
+});
+const xsdStrikeStyle = bidi({
+	singleStrike: "sngStrike",
+	doubleStrike: "dblStrike",
+	noStrike: "noStrike"
+});
+const xsdTextCaps = bidi({
+	none: "none",
+	all: "all",
+	small: "small"
+});
+//#endregion
+//#region src/drawingml/blip/tile.ts
+/**
+* Tile fill module for blip fills.
+*
+* This module defines how images are tiled (repeated) to fill shapes.
+*
+* Reference: ISO/IEC 29500-4, dml-main.xsd, CT_TileInfoProperties
+*
+* @module
+*/
+/**
+* Tile alignment within the shape.
+*
+* Specifies the anchor position of the first tile relative to the shape.
+*/
+const TileAlignment = {
+	/** Top-left corner */
+	TOP_LEFT: "topLeft",
+	/** Top center */
+	TOP: "top",
+	/** Top-right corner */
+	TOP_RIGHT: "topRight",
+	/** Middle-left */
+	LEFT: "left",
+	/** Center */
+	CENTER: "center",
+	/** Middle-right */
+	RIGHT: "right",
+	/** Bottom-left corner */
+	BOTTOM_LEFT: "bottomLeft",
+	/** Bottom center */
+	BOTTOM: "bottom",
+	/** Bottom-right corner */
+	BOTTOM_RIGHT: "bottomRight"
+};
+/**
+* Creates a tile fill mode element for blip fills.
+*
+* When a blip fill uses tile mode, the image is repeated (tiled) to fill
+* the shape instead of being stretched. This element controls the tiling
+* parameters such as offset, scale, flip, and alignment.
+*
+* Reference: ISO/IEC 29500-4, dml-main.xsd, CT_TileInfoProperties
+*
+* ## XSD Schema
+* ```xml
+* <xsd:complexType name="CT_TileInfoProperties">
+*   <xsd:attribute name="tx" type="ST_Coordinate" use="optional"/>
+*   <xsd:attribute name="ty" type="ST_Coordinate" use="optional"/>
+*   <xsd:attribute name="sx" type="ST_Percentage" use="optional"/>
+*   <xsd:attribute name="sy" type="ST_Percentage" use="optional"/>
+*   <xsd:attribute name="flip" type="ST_TileFlipMode" default="none"/>
+*   <xsd:attribute name="algn" type="ST_RectAlignment" use="optional"/>
+* </xsd:complexType>
+* ```
+*
+* @example
+* ```typescript
+* // Tile with 50% scale
+* createTileInfo({ sx: 50, sy: 50 });
+* // Tile with flip and alignment
+* createTileInfo({ flip: "XY", align: "CENTER" });
+* ```
+*/
+const createTileInfo = (options) => {
+	if (!options) return new BuilderElement({ name: "a:tile" });
+	const attributes = {};
+	if (options.tx !== void 0) attributes.tx = {
+		key: "tx",
+		value: options.tx
+	};
+	if (options.ty !== void 0) attributes.ty = {
+		key: "ty",
+		value: options.ty
+	};
+	if (options.sx !== void 0) attributes.sx = {
+		key: "sx",
+		value: options.sx
+	};
+	if (options.sy !== void 0) attributes.sy = {
+		key: "sy",
+		value: options.sy
+	};
+	if (options.flip !== void 0) attributes.flip = {
+		key: "flip",
+		value: options.flip
+	};
+	if (options.align !== void 0) attributes.algn = {
+		key: "algn",
+		value: xsdRectAlignment.to(options.align)
+	};
+	return new BuilderElement({
+		attributes: Object.keys(attributes).length > 0 ? attributes : void 0,
+		name: "a:tile"
+	});
+};
+//#endregion
+//#region src/drawingml/fill/gradient-fill.ts
+/**
+* Gradient fill element for DrawingML shapes.
+*
+* This module provides gradient fill support with linear and path shading.
+*
+* Reference: ISO/IEC 29500-4, dml-main.xsd, CT_GradientFillProperties
+*
+* @module
+*/
+/**
+* Path shade type for radial gradients.
+*/
+const PathShadeType = {
+	/** Follow shape path */
+	SHAPE: "shape",
+	/** Circular gradient */
+	CIRCLE: "circle",
+	/** Rectangular gradient */
+	RECT: "rect"
+};
+/**
+* Tile flip mode for gradient fill.
+*
+* ## XSD Schema
+* ```xml
+* <xsd:simpleType name="ST_TileFlipMode">
+*   <xsd:restriction base="xsd:string">
+*     <xsd:enumeration value="none"/>
+*     <xsd:enumeration value="x"/>
+*     <xsd:enumeration value="y"/>
+*     <xsd:enumeration value="xy"/>
+*   </xsd:restriction>
+* </xsd:simpleType>
+* ```
+*/
+const TileFlipMode = {
+	/** No flip */
+	NONE: "none",
+	/** Flip horizontally */
+	X: "x",
+	/** Flip vertically */
+	Y: "y",
+	/** Flip both horizontally and vertically */
+	XY: "xy"
+};
+/**
+* Creates a gradient stop element (a:gs).
+*
+* @example
+* ```typescript
+* createGradientStop({ position: 0, color: { value: "FF0000" } });
+* createGradientStop({ position: 100000, color: { value: "0000FF" } });
+* ```
+*/
+const createGradientStop = (stop) => new BuilderElement({
+	attributes: { pos: {
+		key: "pos",
+		value: stop.position
+	} },
+	children: [createColorElement(stop.color)],
+	name: "a:gs"
+});
+/**
+* Creates a relative rect element.
+*/
+const createRelativeRect = (name, rect) => new BuilderElement({
+	attributes: {
+		l: {
+			key: "l",
+			value: rect?.left
+		},
+		t: {
+			key: "t",
+			value: rect?.top
+		},
+		r: {
+			key: "r",
+			value: rect?.right
+		},
+		b: {
+			key: "b",
+			value: rect?.bottom
+		}
+	},
+	name
+});
+/**
+* Creates the shade element (a:lin or a:path).
+*/
+const createShadeElement = (shade) => {
+	if ("angle" in shade) return new BuilderElement({
+		attributes: {
+			ang: {
+				key: "ang",
+				value: shade.angle
+			},
+			scaled: {
+				key: "scaled",
+				value: shade.scaled
+			}
+		},
+		name: "a:lin"
+	});
+	const pathShade = shade;
+	const children = [];
+	if (pathShade.fillToRect) children.push(createRelativeRect("a:fillToRect", pathShade.fillToRect));
+	return new BuilderElement({
+		attributes: { path: {
+			key: "path",
+			value: pathShade.path
+		} },
+		children,
+		name: "a:path"
+	});
+};
+/**
+* Creates a gradient fill element.
+*
+* ## XSD Schema
+* ```xml
+* <xsd:complexType name="CT_GradientFillProperties">
+*   <xsd:sequence>
+*     <xsd:element name="gsLst" type="CT_GradientStopList" minOccurs="0"/>
+*     <xsd:group ref="EG_ShadeProperties" minOccurs="0"/>
+*   </xsd:sequence>
+*   <xsd:attribute name="rotWithShape" type="xsd:boolean" use="optional"/>
+* </xsd:complexType>
+* ```
+*
+* @example
+* ```typescript
+* // Linear gradient from red to blue
+* createGradientFill({
+*   stops: [
+*     { position: 0, color: { value: "FF0000" } },
+*     { position: 100000, color: { value: "0000FF" } },
+*   ],
+*   shade: { angle: 5400000 },
+* });
+* ```
+*/
+const createGradientFill = (options) => {
+	const children = [];
+	children.push(new BuilderElement({
+		children: options.stops.map(createGradientStop),
+		name: "a:gsLst"
+	}));
+	if (options.shade) children.push(createShadeElement(options.shade));
+	if (options.tileRect) children.push(createRelativeRect("a:tileRect", options.tileRect));
+	return new BuilderElement({
+		attributes: {
+			flip: {
+				key: "flip",
+				value: options.flip
+			},
+			rotWithShape: {
+				key: "rotWithShape",
+				value: options.rotateWithShape
+			}
+		},
+		children,
+		name: "a:gradFill"
+	});
+};
+//#endregion
+//#region src/drawingml/fill/pattern-fill.ts
+/**
+* Pattern fill element for DrawingML shapes.
+*
+* This module provides pattern fill support with preset patterns and
+* optional foreground/background colors.
+*
+* Reference: ISO/IEC 29500-4, dml-main.xsd, CT_PatternFillProperties
+*
+* @module
+*/
+/**
+* Preset pattern values for pattern fill.
+*
+* ## XSD Schema
+* ```xml
+* <xsd:simpleType name="ST_PresetPatternVal">
+*   <xsd:restriction base="xsd:token">
+*     <xsd:enumeration value="pct5"/> ... <xsd:enumeration value="zigZag"/>
+*   </xsd:restriction>
+* </xsd:simpleType>
+* ```
+*
+* @publicApi
+*/
+const PresetPattern = {
+	/** 5% pattern */
+	PCT5: "percent5",
+	/** 10% pattern */
+	PCT10: "percent10",
+	/** 20% pattern */
+	PCT20: "percent20",
+	/** 25% pattern */
+	PCT25: "percent25",
+	/** 30% pattern */
+	PCT30: "percent30",
+	/** 40% pattern */
+	PCT40: "percent40",
+	/** 50% pattern */
+	PCT50: "percent50",
+	/** 60% pattern */
+	PCT60: "percent60",
+	/** 70% pattern */
+	PCT70: "percent70",
+	/** 75% pattern */
+	PCT75: "percent75",
+	/** 80% pattern */
+	PCT80: "percent80",
+	/** 90% pattern */
+	PCT90: "percent90",
+	/** Horizontal lines */
+	HORZ: "horizontal",
+	/** Vertical lines */
+	VERT: "vertical",
+	/** Light horizontal lines */
+	LT_HORZ: "lightHorizontal",
+	/** Light vertical lines */
+	LT_VERT: "lightVertical",
+	/** Dark horizontal lines */
+	DK_HORZ: "darkHorizontal",
+	/** Dark vertical lines */
+	DK_VERT: "darkVertical",
+	/** Narrow horizontal lines */
+	NAR_HORZ: "narrowHorizontal",
+	/** Narrow vertical lines */
+	NAR_VERT: "narrowVertical",
+	/** Dashed horizontal lines */
+	DASH_HORZ: "dashedHorizontal",
+	/** Dashed vertical lines */
+	DASH_VERT: "dashedVertical",
+	/** Cross pattern (+) */
+	CROSS: "cross",
+	/** Downward diagonal lines (\) */
+	DN_DIAG: "downDiagonal",
+	/** Upward diagonal lines (/) */
+	UP_DIAG: "upDiagonal",
+	/** Light downward diagonal lines */
+	LT_DN_DIAG: "lightDownDiagonal",
+	/** Light upward diagonal lines */
+	LT_UP_DIAG: "lightUpDiagonal",
+	/** Dark downward diagonal lines */
+	DK_DN_DIAG: "darkDownDiagonal",
+	/** Dark upward diagonal lines */
+	DK_UP_DIAG: "darkUpDiagonal",
+	/** Wide downward diagonal lines */
+	WD_DN_DIAG: "wideDownDiagonal",
+	/** Wide upward diagonal lines */
+	WD_UP_DIAG: "wideUpDiagonal",
+	/** Dashed downward diagonal lines */
+	DASH_DN_DIAG: "dashedDownDiagonal",
+	/** Dashed upward diagonal lines */
+	DASH_UP_DIAG: "dashedUpDiagonal",
+	/** Diagonal cross pattern (X) */
+	DIAG_CROSS: "diagonalCross",
+	/** Small checkerboard */
+	SM_CHECK: "smallChecker",
+	/** Large checkerboard */
+	LG_CHECK: "largeChecker",
+	/** Small grid */
+	SM_GRID: "smallGrid",
+	/** Large grid */
+	LG_GRID: "largeGrid",
+	/** Dot grid */
+	DOT_GRID: "dotGrid",
+	/** Small confetti */
+	SM_CONFETTI: "smallConfetti",
+	/** Large confetti */
+	LG_CONFETTI: "largeConfetti",
+	/** Horizontal brick pattern */
+	HORZ_BRICK: "horizontalBrick",
+	/** Diagonal brick pattern */
+	DIAG_BRICK: "diagonalBrick",
+	/** Solid diamond */
+	SOLID_DMND: "solidDiamond",
+	/** Open diamond */
+	OPEN_DMND: "openDiamond",
+	/** Dotted diamond */
+	DOT_DMND: "dottedDiamond",
+	/** Plaid pattern */
+	PLAID: "plaid",
+	/** Sphere pattern */
+	SPHERE: "sphere",
+	/** Weave pattern */
+	WEAVE: "weave",
+	/** Divot pattern */
+	DIVOT: "divot",
+	/** Shingle pattern */
+	SHINGLE: "shingle",
+	/** Wave pattern */
+	WAVE: "wave",
+	/** Trellis pattern */
+	TRELLIS: "trellis",
+	/** Zigzag pattern */
+	ZIG_ZAG: "zigZag"
+};
+/**
+* Creates a pattern fill element (a:pattFill).
+*
+* Specifies a pattern fill using preset patterns with optional
+* foreground and background colors.
+*
+* ## XSD Schema
+* ```xml
+* <xsd:complexType name="CT_PatternFillProperties">
+*   <xsd:sequence>
+*     <xsd:element name="fgClr" type="CT_Color" minOccurs="0"/>
+*     <xsd:element name="bgClr" type="CT_Color" minOccurs="0"/>
+*   </xsd:sequence>
+*   <xsd:attribute name="prst" type="ST_PresetPatternVal" use="optional"/>
+* </xsd:complexType>
+* ```
+*
+* @example
+* ```typescript
+* // Simple crosshatch pattern
+* createPatternFill({ pattern: PresetPattern.CROSS });
+* // Pattern with foreground color
+* createPatternFill({
+*   pattern: PresetPattern.DIAG_CROSS,
+*   foregroundColor: { value: "FF0000" },
+* });
+* // Pattern with foreground and background colors
+* createPatternFill({
+*   pattern: PresetPattern.HORZ,
+*   foregroundColor: { value: "0000FF" },
+*   backgroundColor: { value: "FFFF00" },
+* });
+* ```
+*/
+const createPatternFill = (options) => {
+	const children = [];
+	if (options.foregroundColor) children.push(new BuilderElement({
+		children: [createColorElement(options.foregroundColor)],
+		name: "a:fgClr"
+	}));
+	if (options.backgroundColor) children.push(new BuilderElement({
+		children: [createColorElement(options.backgroundColor)],
+		name: "a:bgClr"
+	}));
+	return new BuilderElement({
+		attributes: { prst: {
+			key: "prst",
+			value: xsdPattern.to(options.pattern)
+		} },
+		children,
+		name: "a:pattFill"
+	});
+};
+//#endregion
+//#region src/drawingml/fill/fill-options.ts
+function normalizeColor(color) {
+	return typeof color === "string" ? { value: color.replace("#", "") } : color;
+}
+function toUint8Array(data) {
+	return data instanceof Uint8Array ? data : new Uint8Array(data);
+}
+/**
+* Extracts media data from a blip fill option, if present.
+* Returns undefined for non-blip fills.
+*
+* The returned data should be registered with the document's media store
+* during `prepForXml` so the packer can resolve the `{fileName}` placeholder.
+*/
+const extractBlipFillMedia = (fill) => {
+	if (typeof fill === "string" || fill.type !== "blip") return void 0;
+	const raw = toUint8Array(fill.data);
+	return {
+		data: raw,
+		fileName: `${hashedId(raw)}.${fill.imageType}`,
+		type: fill.imageType
+	};
+};
+/**
+* Builds a DrawingML fill XmlComponent from a FillOptions config.
+*/
+const buildFill = (options) => {
+	if (typeof options === "string") return createSolidFill({ value: options.replace("#", "") });
+	switch (options.type) {
+		case "solid": return createSolidFill(normalizeColor(options.color));
+		case "none": return new BuilderElement({ name: "a:noFill" });
+		case "gradient":
+			if ("options" in options) return createGradientFill(options.options);
+			return createGradientFill({
+				stops: options.stops.map((stop) => ({
+					position: stop.position * 1e3,
+					color: normalizeColor(stop.color)
+				})),
+				...!options.path && options.angle !== void 0 && { shade: {
+					angle: options.angle * 6e4,
+					scaled: options.scaled ?? true
+				} },
+				...options.path && { shade: { path: options.path } }
+			});
+		case "blip": {
+			const fileName = `${hashedId(toUint8Array(options.data))}.${options.imageType}`;
+			const blipChildren = [];
+			if (options.blipEffects) blipChildren.push(...createBlipEffects(options.blipEffects));
+			const children = [new BuilderElement({
+				attributes: {
+					cstate: {
+						key: "cstate",
+						value: "none"
+					},
+					embed: {
+						key: "r:embed",
+						value: `{${fileName}}`
+					}
+				},
+				children: blipChildren,
+				name: "a:blip"
+			}), createSourceRectangle(options.srcRect)];
+			if (options.tile) children.push(createTileInfo(options.tile));
+			else children.push(new Stretch());
+			const attributes = {};
+			if (options.dpi !== void 0) attributes.dpi = {
+				key: "dpi",
+				value: options.dpi
+			};
+			if (options.rotWithShape !== void 0) attributes.rotWithShape = {
+				key: "rotWithShape",
+				value: options.rotWithShape ? 1 : 0
+			};
+			return new BuilderElement({
+				attributes: Object.keys(attributes).length > 0 ? attributes : void 0,
+				children,
+				name: "a:blipFill"
+			});
+		}
+		case "pattern": return createPatternFill({
+			pattern: options.pattern,
+			...options.foregroundColor && { foregroundColor: normalizeColor(options.foregroundColor) },
+			...options.backgroundColor && { backgroundColor: normalizeColor(options.backgroundColor) }
+		});
+		case "group": return new BuilderElement({ name: "a:grpFill" });
+	}
+};
+//#endregion
+//#region src/drawingml/fill/no-fill.ts
+/**
+* No fill element for DrawingML shapes.
+*
+* This module provides the no-fill option for outline and shape fills.
+*
+* @module
+*/
+/**
+* Creates a no-fill element.
+*
+* Specifies that the outline or shape should have no fill applied.
+*
+* ## XSD Schema
+* ```xml
+* <xsd:element name="noFill" type="CT_Empty"/>
+* ```
+*
+* @example
+* ```typescript
+* const noFill = createNoFill();
+* ```
+*/
+const createNoFill = () => new BuilderElement({ name: "a:noFill" });
+//#endregion
+//#region src/drawingml/fill/group-fill.ts
+/**
+* Group fill element for DrawingML shapes.
+*
+* This module provides group fill support which inherits the fill
+* from the parent group shape.
+*
+* Reference: ISO/IEC 29500-4, dml-main.xsd, CT_GroupFillProperties
+*
+* @module
+*/
+/**
+* Creates a group fill element (a:grpFill).
+*
+* This element specifies that the shape should inherit its fill
+* from the parent group shape. This is useful when shapes are
+* grouped together and should share the same fill.
+*
+* ## XSD Schema
+* ```xml
+* <xsd:complexType name="CT_GroupFillProperties"/>
+* ```
+*
+* @example
+* ```typescript
+* // Shape inherits fill from parent group
+* createGroupFill();
+* ```
+*/
+const createGroupFill = () => new BuilderElement({ name: "a:grpFill" });
+//#endregion
+//#region src/drawingml/outline/custom-dash.ts
+/**
+* Custom dash pattern for DrawingML outlines.
+*
+* This module provides support for custom dash patterns defined by
+* a list of dash stops, each specifying dash and space lengths as
+* percentages relative to line width.
+*
+* Reference: ISO/IEC 29500-4, dml-main.xsd, CT_DashStopList, CT_DashStop
+*
+* @module
+*/
+/**
+* Creates a custom dash element (a:custDash) for outlines.
+*
+* The custom dash element specifies a repeating pattern of dash and space
+* segments. Each segment is defined by a `DashStop` with dash (`d`) and
+* space (`sp`) lengths as positive percentages of the line width.
+*
+* ## XSD Schema
+* ```xml
+* <xsd:complexType name="CT_DashStopList">
+*   <xsd:sequence>
+*     <xsd:element name="ds" type="CT_DashStop" minOccurs="0" maxOccurs="unbounded"/>
+*   </xsd:sequence>
+* </xsd:complexType>
+* ```
+*
+* @example
+* ```typescript
+* // Simple dash pattern
+* createCustomDash([
+*   { d: "500%", sp: "200%" },
+* ]);
+*
+* // Complex alternating pattern
+* createCustomDash([
+*   { d: "500%", sp: "200%" },
+*   { d: "100%", sp: "200%" },
+* ]);
+* ```
+*/
+const createCustomDash = (stops) => {
+	const children = [];
+	for (const stop of stops) children.push(new BuilderElement({
+		attributes: {
+			d: {
+				key: "d",
+				value: stop.d
+			},
+			sp: {
+				key: "sp",
+				value: stop.sp
+			}
+		},
+		name: "a:ds"
+	}));
+	return new BuilderElement({
+		children,
+		name: "a:custDash"
+	});
+};
+//#endregion
+//#region src/drawingml/outline/line-end.ts
+/**
+* Line end (arrow) properties for DrawingML outlines.
+*
+* This module provides support for line end markers (arrows) on shape outlines.
+*
+* Reference: ISO/IEC 29500-4, dml-main.xsd, CT_LineEndProperties
+*
+* @module
+*/
+/**
+* Line end types (arrow head styles).
+*
+* ## XSD Schema
+* ```xml
+* <xsd:simpleType name="ST_LineEndType">
+*   <xsd:restriction base="xsd:token">
+*     <xsd:enumeration value="none"/>
+*     <xsd:enumeration value="triangle"/>
+*     <xsd:enumeration value="stealth"/>
+*     <xsd:enumeration value="diamond"/>
+*     <xsd:enumeration value="oval"/>
+*     <xsd:enumeration value="arrow"/>
+*   </xsd:restriction>
+* </xsd:simpleType>
+* ```
+*
+* @publicApi
+*/
+const LineEndType = {
+	/** No line end */
+	NONE: "none",
+	/** Triangle arrow */
+	TRIANGLE: "triangle",
+	/** Stealth arrow (filled triangle) */
+	STEALTH: "stealth",
+	/** Diamond shape */
+	DIAMOND: "diamond",
+	/** Oval shape */
+	OVAL: "oval",
+	/** Simple arrow */
+	ARROW: "arrow"
+};
+/**
+* Line end width options.
+*
+* ## XSD Schema
+* ```xml
+* <xsd:simpleType name="ST_LineEndWidth">
+*   <xsd:restriction base="xsd:token">
+*     <xsd:enumeration value="sm"/>
+*     <xsd:enumeration value="med"/>
+*     <xsd:enumeration value="lg"/>
+*   </xsd:restriction>
+* </xsd:simpleType>
+* ```
+*
+* @publicApi
+*/
+const LineEndWidth = {
+	/** Small width */
+	SMALL: "small",
+	/** Medium width */
+	MEDIUM: "medium",
+	/** Large width */
+	LARGE: "large"
+};
+/**
+* Line end length options.
+*
+* ## XSD Schema
+* ```xml
+* <xsd:simpleType name="ST_LineEndLength">
+*   <xsd:restriction base="xsd:token">
+*     <xsd:enumeration value="sm"/>
+*     <xsd:enumeration value="med"/>
+*     <xsd:enumeration value="lg"/>
+*   </xsd:restriction>
+* </xsd:simpleType>
+* ```
+*
+* @publicApi
+*/
+const LineEndLength = {
+	/** Small length */
+	SMALL: "small",
+	/** Medium length */
+	MEDIUM: "medium",
+	/** Large length */
+	LARGE: "large"
+};
+/**
+* Creates a line end element (a:headEnd or a:tailEnd).
+*
+* @example
+* ```typescript
+* // Stealth arrow at start, medium size
+* createLineEnd("a:headEnd", { type: "STEALTH", width: "MEDIUM", length: "MEDIUM" });
+* // Triangle arrow at end
+* createLineEnd("a:tailEnd", { type: "TRIANGLE" });
+* ```
+*/
+const createLineEnd = (name, options) => new BuilderElement({
+	attributes: {
+		type: {
+			key: "type",
+			value: options.type
+		},
+		w: {
+			key: "w",
+			value: options.width ? xsdLineEndSize.to(options.width) : void 0
+		},
+		len: {
+			key: "len",
+			value: options.length ? xsdLineEndSize.to(options.length) : void 0
+		}
+	},
+	name
+});
+//#endregion
+//#region src/drawingml/outline/outline.ts
+/**
+* Outline (line) properties for DrawingML shapes.
+*
+* This module provides support for configuring outline properties including
+* width, cap style, compound line types, fill properties, dash, and join.
+*
+* Reference: ISO/IEC 29500-4, dml-main.xsd, CT_LineProperties
+*
+* @module
+*/
+/**
+* Line cap styles for outline endpoints.
+*
+* Defines how the ends of a line are rendered.
+*/
+const LineCap = {
+	/** Round cap style */
+	ROUND: "round",
+	/** Square cap style */
+	SQUARE: "square",
+	/** Flat cap style */
+	FLAT: "flat"
+};
+/**
+* Compound line types for outlines.
+*
+* Defines the structure of compound lines (single, double, etc.).
+*/
+const CompoundLine = {
+	/** Single line */
+	SINGLE: "single",
+	/** Double line */
+	DOUBLE: "double",
+	/** Thick-thin double line */
+	THICK_THIN: "thickThin",
+	/** Thin-thick double line */
+	THIN_THICK: "thinThick",
+	/** Triple line */
+	TRI: "triple"
+};
+/**
+* Pen alignment options for outline positioning.
+*
+* Defines how the outline is aligned relative to the shape edge.
+*/
+const PenAlignment = {
+	/** Center alignment */
+	CENTER: "center",
+	/** Inset alignment */
+	INSET: "inside"
+};
+/**
+* Preset dash styles for outlines.
+*
+* ## XSD Schema
+* ```xml
+* <xsd:simpleType name="ST_PresetLineDashVal">
+*   <xsd:restriction base="xsd:token">
+*     <xsd:enumeration value="solid"/>
+*     <xsd:enumeration value="dot"/>
+*     <xsd:enumeration value="dash"/>
+*     <xsd:enumeration value="lgDash"/>
+*     <xsd:enumeration value="dashDot"/>
+*     <xsd:enumeration value="lgDashDot"/>
+*     <xsd:enumeration value="lgDashDotDot"/>
+*     <xsd:enumeration value="sysDash"/>
+*     <xsd:enumeration value="sysDot"/>
+*     <xsd:enumeration value="sysDashDot"/>
+*     <xsd:enumeration value="sysDashDotDot"/>
+*   </xsd:restriction>
+* </xsd:simpleType>
+* ```
+*/
+const PresetDash = {
+	SOLID: "solid",
+	DOT: "dot",
+	DASH: "dash",
+	LG_DASH: "lgDash",
+	DASH_DOT: "dashDot",
+	LG_DASH_DOT: "lgDashDot",
+	LG_DASH_DOT_DOT: "lgDashDotDot",
+	SYS_DASH: "sysDash",
+	SYS_DOT: "sysDot",
+	SYS_DASH_DOT: "sysDashDot",
+	SYS_DASH_DOT_DOT: "sysDashDotDot"
+};
+/**
+* Line join styles.
+*/
+const LineJoin = {
+	ROUND: "round",
+	BEVEL: "bevel",
+	MITER: "miter"
+};
+/**
+* Creates the fill child element for an outline.
+*
+* Returns null when no fill type is specified (OOXML allows outline without fill).
+*/
+const createOutlineFill = (options) => {
+	if (options.type === "noFill") return createNoFill();
+	if (options.type === "solidFill" && options.color) return createSolidFill(options.color);
+	if (options.type === "gradFill" && options.gradientFill) return createGradientFill(options.gradientFill);
+	if (options.type === "pattFill" && options.patternFill) return createPatternFill(options.patternFill);
+	return null;
+};
+/**
+* Creates an outline element for DrawingML shapes.
+*
+* The outline element specifies the line properties for the shape border,
+* including width, cap style, compound line type, alignment, dash, join, and fill.
+*
+* ## XSD Schema
+* ```xml
+* <xsd:complexType name="CT_LineProperties">
+*   <xsd:sequence>
+*     <xsd:group ref="EG_FillProperties" minOccurs="0"/>
+*     <xsd:group ref="EG_LineDashProperties" minOccurs="0"/>
+*     <xsd:group ref="EG_LineJoinProperties" minOccurs="0"/>
+*   </xsd:sequence>
+*   <xsd:attribute name="w" use="optional" type="a:ST_LineWidth"/>
+*   <xsd:attribute name="cap" use="optional" type="ST_LineCap"/>
+*   <xsd:attribute name="cmpd" use="optional" type="ST_CompoundLine"/>
+*   <xsd:attribute name="algn" use="optional" type="ST_PenAlignment"/>
+* </xsd:complexType>
+* ```
+*
+* @example
+* ```typescript
+* // Outline with RGB color and dash
+* const outline = createOutline({
+*   width: 9525,
+*   type: "solidFill",
+*   color: { value: "FF0000" },
+*   dash: "DASH",
+* });
+* ```
+*/
+const createOutline = (options) => {
+	const children = [];
+	const fill = createOutlineFill(options);
+	if (fill) children.push(fill);
+	if (options.customDash !== void 0) children.push(createCustomDash(options.customDash));
+	else if (options.dash !== void 0) children.push(new BuilderElement({
+		attributes: { val: {
+			key: "val",
+			value: options.dash
+		} },
+		name: "a:prstDash"
+	}));
+	if (options.join !== void 0) if (options.join === "miter" && options.miterLimit !== void 0) children.push(new BuilderElement({
+		attributes: { lim: {
+			key: "lim",
+			value: options.miterLimit
+		} },
+		name: "a:miter"
+	}));
+	else children.push(new BuilderElement({ name: `a:${options.join}` }));
+	if (options.headEnd) children.push(createLineEnd("a:headEnd", options.headEnd));
+	if (options.tailEnd) children.push(createLineEnd("a:tailEnd", options.tailEnd));
+	return new BuilderElement({
+		attributes: {
+			align: {
+				key: "algn",
+				value: options.align ? xsdPenAlignment.to(options.align) : void 0
+			},
+			cap: {
+				key: "cap",
+				value: options.cap ? xsdLineCap.to(options.cap) : void 0
+			},
+			compoundLine: {
+				key: "cmpd",
+				value: options.compoundLine ? xsdCompoundLine.to(options.compoundLine) : void 0
+			},
+			width: {
+				key: "w",
+				value: options.width
+			}
+		},
+		children,
+		name: "a:ln"
+	});
+};
+//#endregion
+//#region src/drawingml/effects/fill-overlay.ts
+/**
+* Fill overlay effect for DrawingML shapes.
+*
+* Reference: ISO/IEC 29500-4, dml-main.xsd, CT_FillOverlayEffect
+*
+* @module
+*/
+/**
+* Blend modes for fill overlay effect.
+*
+* ## XSD Schema
+* ```xml
+* <xsd:simpleType name="ST_BlendMode">
+*   <xsd:restriction base="xsd:token">
+*     <xsd:enumeration value="over"/>
+*     <xsd:enumeration value="mult"/>
+*     <xsd:enumeration value="screen"/>
+*     <xsd:enumeration value="darken"/>
+*     <xsd:enumeration value="lighten"/>
+*   </xsd:restriction>
+* </xsd:simpleType>
+* ```
+*/
+const BlendMode = {
+	/** Over blend mode */
+	OVER: "over",
+	/** Multiply blend mode */
+	MULTIPLY: "multiply",
+	/** Screen blend mode */
+	SCREEN: "screen",
+	/** Darken blend mode */
+	DARKEN: "darken",
+	/** Lighten blend mode */
+	LIGHTEN: "lighten"
+};
+/**
+* Creates a fill overlay effect element.
+*
+* ## XSD Schema
+* ```xml
+* <xsd:complexType name="CT_FillOverlayEffect">
+*   <xsd:sequence>
+*     <xsd:group ref="EG_FillProperties" minOccurs="1" maxOccurs="1"/>
+*   </xsd:sequence>
+*   <xsd:attribute name="blend" type="ST_BlendMode" use="required"/>
+* </xsd:complexType>
+* ```
+*
+* @example
+* ```typescript
+* // Solid fill overlay
+* const fillOverlay = createFillOverlayEffect({
+*   blend: BlendMode.MULTIPLY,
+*   solidFill: { value: "FF0000" },
+* });
+*
+* // Gradient fill overlay
+* const fillOverlay = createFillOverlayEffect({
+*   blend: BlendMode.SCREEN,
+*   gradientFill: { type: "linear", stops: [...] },
+* });
+* ```
+*/
+const createFillOverlayEffect = (options) => {
+	let fillElement;
+	if (options.noFill) fillElement = createNoFill();
+	else if (options.solidFill) fillElement = createSolidFill(options.solidFill);
+	else if (options.gradientFill) fillElement = createGradientFill(options.gradientFill);
+	else if (options.patternFill) fillElement = createPatternFill(options.patternFill);
+	else if (options.groupFill) fillElement = createGroupFill();
+	else fillElement = createSolidFill({ value: "000000" });
+	return new BuilderElement({
+		attributes: { blend: {
+			key: "blend",
+			value: xsdBlendMode.to(options.blend)
+		} },
+		children: [fillElement],
+		name: "a:fillOverlay"
+	});
+};
+//#endregion
+//#region src/drawingml/effects/glow.ts
+/**
+* Glow effect for DrawingML shapes.
+*
+* Reference: ISO/IEC 29500-4, dml-main.xsd, CT_GlowEffect
+*
+* @module
+*/
+/**
+* Creates a glow effect element.
+*
+* ## XSD Schema
+* ```xml
+* <xsd:complexType name="CT_GlowEffect">
+*   <xsd:sequence>
+*     <xsd:group ref="EG_ColorChoice" minOccurs="1" maxOccurs="1"/>
+*   </xsd:sequence>
+*   <xsd:attribute name="rad" type="ST_PositiveCoordinate" use="optional" default="0"/>
+* </xsd:complexType>
+* ```
+*/
+const createGlowEffect = (options) => {
+	if (options.radius === void 0) return new BuilderElement({
+		children: [createColorElement(options.color)],
+		name: "a:glow"
+	});
+	return new BuilderElement({
+		attributes: { rad: {
+			key: "rad",
+			value: options.radius
+		} },
+		children: [createColorElement(options.color)],
+		name: "a:glow"
+	});
+};
+//#endregion
+//#region src/drawingml/effects/inner-shadow.ts
+/**
+* Inner shadow effect for DrawingML shapes.
+*
+* Reference: ISO/IEC 29500-4, dml-main.xsd, CT_InnerShadowEffect
+*
+* @module
+*/
+/**
+* Creates an inner shadow effect element.
+*
+* ## XSD Schema
+* ```xml
+* <xsd:complexType name="CT_InnerShadowEffect">
+*   <xsd:sequence>
+*     <xsd:group ref="EG_ColorChoice" minOccurs="1" maxOccurs="1"/>
+*   </xsd:sequence>
+*   <xsd:attribute name="blurRad" type="ST_PositiveCoordinate" default="0"/>
+*   <xsd:attribute name="dist" type="ST_PositiveCoordinate" default="0"/>
+*   <xsd:attribute name="dir" type="ST_PositiveFixedAngle" default="0"/>
+* </xsd:complexType>
+* ```
+*/
+const createInnerShadowEffect = (options) => {
+	if (!(options.blurRadius !== void 0 || options.distance !== void 0 || options.direction !== void 0)) return new BuilderElement({
+		children: [createColorElement(options.color)],
+		name: "a:innerShdw"
+	});
+	return new BuilderElement({
+		attributes: {
+			...options.blurRadius !== void 0 && { blurRad: {
+				key: "blurRad",
+				value: options.blurRadius
+			} },
+			...options.distance !== void 0 && { dist: {
+				key: "dist",
+				value: options.distance
+			} },
+			...options.direction !== void 0 && { dir: {
+				key: "dir",
+				value: options.direction
+			} }
+		},
+		children: [createColorElement(options.color)],
+		name: "a:innerShdw"
+	});
+};
+//#endregion
+//#region src/drawingml/effects/outer-shadow.ts
+/**
+* Outer shadow effect for DrawingML shapes.
+*
+* Reference: ISO/IEC 29500-4, dml-main.xsd, CT_OuterShadowEffect
+*
+* @module
+*/
+/**
+* Rectangle alignment for shadow positioning.
+*/
+const RectAlignment = {
+	TOP_LEFT: "topLeft",
+	TOP: "top",
+	TOP_RIGHT: "topRight",
+	LEFT: "left",
+	CENTER: "center",
+	RIGHT: "right",
+	BOTTOM_LEFT: "bottomLeft",
+	BOTTOM: "bottom",
+	BOTTOM_RIGHT: "bottomRight"
+};
+/**
+* Creates an outer shadow effect element.
+*
+* ## XSD Schema
+* ```xml
+* <xsd:complexType name="CT_OuterShadowEffect">
+*   <xsd:sequence>
+*     <xsd:group ref="EG_ColorChoice" minOccurs="1" maxOccurs="1"/>
+*   </xsd:sequence>
+*   <xsd:attribute name="blurRad" type="ST_PositiveCoordinate" default="0"/>
+*   <xsd:attribute name="dist" type="ST_PositiveCoordinate" default="0"/>
+*   <xsd:attribute name="dir" type="ST_PositiveFixedAngle" default="0"/>
+*   <xsd:attribute name="sx" type="ST_Percentage" default="100%"/>
+*   <xsd:attribute name="sy" type="ST_Percentage" default="100%"/>
+*   <xsd:attribute name="kx" type="ST_FixedAngle" default="0"/>
+*   <xsd:attribute name="ky" type="ST_FixedAngle" default="0"/>
+*   <xsd:attribute name="algn" type="ST_RectAlignment" default="b"/>
+*   <xsd:attribute name="rotWithShape" type="xsd:boolean" default="true"/>
+* </xsd:complexType>
+* ```
+*/
+const createOuterShadowEffect = (options) => {
+	const attributes = {};
+	if (options.blurRadius !== void 0) attributes.blurRad = {
+		key: "blurRad",
+		value: options.blurRadius
+	};
+	if (options.distance !== void 0) attributes.dist = {
+		key: "dist",
+		value: options.distance
+	};
+	if (options.direction !== void 0) attributes.dir = {
+		key: "dir",
+		value: options.direction
+	};
+	if (options.scaleX !== void 0) attributes.sx = {
+		key: "sx",
+		value: options.scaleX
+	};
+	if (options.scaleY !== void 0) attributes.sy = {
+		key: "sy",
+		value: options.scaleY
+	};
+	if (options.skewX !== void 0) attributes.kx = {
+		key: "kx",
+		value: options.skewX
+	};
+	if (options.skewY !== void 0) attributes.ky = {
+		key: "ky",
+		value: options.skewY
+	};
+	if (options.alignment !== void 0) attributes.algn = {
+		key: "algn",
+		value: xsdRectAlignment.to(options.alignment)
+	};
+	if (options.rotWithShape === false) attributes.rotWithShape = {
+		key: "rotWithShape",
+		value: 0
+	};
+	return new BuilderElement({
+		attributes,
+		children: [createColorElement(options.color)],
+		name: "a:outerShdw"
+	});
+};
+//#endregion
+//#region src/drawingml/effects/preset-shadow.ts
+/**
+* Preset shadow effect for DrawingML shapes.
+*
+* Reference: ISO/IEC 29500-4, dml-main.xsd, CT_PresetShadowEffect
+*
+* @module
+*/
+/**
+* Preset shadow types (20 variations).
+*
+* Reference: ISO/IEC 29500-4, dml-main.xsd, ST_PresetShadowVal
+*/
+const PresetShadowVal = {
+	SHDW1: "shadow1",
+	SHDW2: "shadow2",
+	SHDW3: "shadow3",
+	SHDW4: "shadow4",
+	SHDW5: "shadow5",
+	SHDW6: "shadow6",
+	SHDW7: "shadow7",
+	SHDW8: "shadow8",
+	SHDW9: "shadow9",
+	SHDW10: "shadow10",
+	SHDW11: "shadow11",
+	SHDW12: "shadow12",
+	SHDW13: "shadow13",
+	SHDW14: "shadow14",
+	SHDW15: "shadow15",
+	SHDW16: "shadow16",
+	SHDW17: "shadow17",
+	SHDW18: "shadow18",
+	SHDW19: "shadow19",
+	SHDW20: "shadow20"
+};
+/**
+* Creates a preset shadow effect element.
+*
+* ## XSD Schema
+* ```xml
+* <xsd:complexType name="CT_PresetShadowEffect">
+*   <xsd:sequence>
+*     <xsd:group ref="EG_ColorChoice" minOccurs="1" maxOccurs="1"/>
+*   </xsd:sequence>
+*   <xsd:attribute name="prst" type="ST_PresetShadowVal" use="required"/>
+*   <xsd:attribute name="dist" type="ST_PositiveCoordinate" default="0"/>
+*   <xsd:attribute name="dir" type="ST_PositiveFixedAngle" default="0"/>
+* </xsd:complexType>
+* ```
+*/
+const createPresetShadowEffect = (options) => {
+	const attributes = { prst: {
+		key: "prst",
+		value: xsdPresetShadow.to(options.preset)
+	} };
+	if (options.distance !== void 0) attributes.dist = {
+		key: "dist",
+		value: options.distance
+	};
+	if (options.direction !== void 0) attributes.dir = {
+		key: "dir",
+		value: options.direction
+	};
+	return new BuilderElement({
+		attributes,
+		children: [createColorElement(options.color)],
+		name: "a:prstShdw"
+	});
+};
+//#endregion
+//#region src/drawingml/effects/reflection.ts
+/**
+* Reflection effect for DrawingML shapes.
+*
+* Reference: ISO/IEC 29500-4, dml-main.xsd, CT_ReflectionEffect
+*
+* @module
+*/
+/**
+* Creates a reflection effect element.
+*
+* ## XSD Schema
+* ```xml
+* <xsd:complexType name="CT_ReflectionEffect">
+*   <xsd:attribute name="blurRad" type="ST_PositiveCoordinate" default="0"/>
+*   <xsd:attribute name="stA" type="ST_PositiveFixedPercentage" default="100%"/>
+*   <xsd:attribute name="stPos" type="ST_PositiveFixedPercentage" default="0%"/>
+*   <xsd:attribute name="endA" type="ST_PositiveFixedPercentage" default="0%"/>
+*   <xsd:attribute name="endPos" type="ST_PositiveFixedPercentage" default="100%"/>
+*   <xsd:attribute name="dist" type="ST_PositiveCoordinate" default="0"/>
+*   <xsd:attribute name="dir" type="ST_PositiveFixedAngle" default="0"/>
+*   <xsd:attribute name="fadeDir" type="ST_PositiveFixedAngle" default="5400000"/>
+*   <xsd:attribute name="sx" type="ST_Percentage" default="100%"/>
+*   <xsd:attribute name="sy" type="ST_Percentage" default="100%"/>
+*   <xsd:attribute name="kx" type="ST_FixedAngle" default="0"/>
+*   <xsd:attribute name="ky" type="ST_FixedAngle" default="0"/>
+*   <xsd:attribute name="algn" type="ST_RectAlignment" default="b"/>
+*   <xsd:attribute name="rotWithShape" type="xsd:boolean" default="true"/>
+* </xsd:complexType>
+* ```
+*/
+const createReflectionEffect = (options) => {
+	if (!options) return new BuilderElement({ name: "a:reflection" });
+	const attributes = {};
+	if (options.blurRadius !== void 0) attributes.blurRad = {
+		key: "blurRad",
+		value: options.blurRadius
+	};
+	if (options.startAlpha !== void 0) attributes.stA = {
+		key: "stA",
+		value: options.startAlpha
+	};
+	if (options.startPosition !== void 0) attributes.stPos = {
+		key: "stPos",
+		value: options.startPosition
+	};
+	if (options.endAlpha !== void 0) attributes.endA = {
+		key: "endA",
+		value: options.endAlpha
+	};
+	if (options.endPosition !== void 0) attributes.endPos = {
+		key: "endPos",
+		value: options.endPosition
+	};
+	if (options.distance !== void 0) attributes.dist = {
+		key: "dist",
+		value: options.distance
+	};
+	if (options.direction !== void 0) attributes.dir = {
+		key: "dir",
+		value: options.direction
+	};
+	if (options.fadeDirection !== void 0) attributes.fadeDir = {
+		key: "fadeDir",
+		value: options.fadeDirection
+	};
+	if (options.scaleX !== void 0) attributes.sx = {
+		key: "sx",
+		value: options.scaleX
+	};
+	if (options.scaleY !== void 0) attributes.sy = {
+		key: "sy",
+		value: options.scaleY
+	};
+	if (options.skewX !== void 0) attributes.kx = {
+		key: "kx",
+		value: options.skewX
+	};
+	if (options.skewY !== void 0) attributes.ky = {
+		key: "ky",
+		value: options.skewY
+	};
+	if (options.alignment !== void 0) attributes.algn = {
+		key: "algn",
+		value: xsdRectAlignment.to(options.alignment)
+	};
+	if (options.rotWithShape === false) attributes.rotWithShape = {
+		key: "rotWithShape",
+		value: 0
+	};
+	return new BuilderElement({
+		attributes,
+		name: "a:reflection"
+	});
+};
+//#endregion
+//#region src/drawingml/effects/soft-edge.ts
+/**
+* Soft edge effect for DrawingML shapes.
+*
+* Reference: ISO/IEC 29500-4, dml-main.xsd, CT_SoftEdgesEffect
+*
+* @module
+*/
+/**
+* Creates a soft edge effect element.
+*
+* ## XSD Schema
+* ```xml
+* <xsd:complexType name="CT_SoftEdgesEffect">
+*   <xsd:attribute name="rad" type="ST_PositiveCoordinate" use="required"/>
+* </xsd:complexType>
+* ```
+*
+* @param rad - Soft edge radius in EMUs (required)
+*/
+const createSoftEdgeEffect = (rad) => new BuilderElement({
+	attributes: { rad: {
+		key: "rad",
+		value: rad
+	} },
+	name: "a:softEdge"
+});
+//#endregion
+//#region src/drawingml/effects/effect-list.ts
+/**
+* Effect list container for DrawingML shapes.
+*
+* Reference: ISO/IEC 29500-4, dml-main.xsd, CT_EffectList, EG_EffectProperties
+*
+* @module
+*/
+/**
+* Creates a blur effect element.
+*
+* ## XSD Schema
+* ```xml
+* <xsd:complexType name="CT_BlurEffect">
+*   <xsd:attribute name="rad" type="ST_PositiveCoordinate" default="0"/>
+*   <xsd:attribute name="grow" type="xsd:boolean" default="true"/>
+* </xsd:complexType>
+* ```
+*/
+const createBlurEffect$1 = (options) => {
+	if (!(options.radius !== void 0 || options.grow === false)) return new BuilderElement({ name: "a:blur" });
+	return new BuilderElement({
+		attributes: {
+			...options.radius !== void 0 && { rad: {
+				key: "rad",
+				value: options.radius
+			} },
+			...options.grow === false && { grow: {
+				key: "grow",
+				value: 0
+			} }
+		},
+		name: "a:blur"
+	});
+};
+/**
+* Creates an effect list element (a:effectLst).
+*
+* This is the EG_EffectProperties choice for a flat list of effects.
+* Effects are emitted in XSD order: blur, glow, innerShdw, outerShdw, prstShdw, reflection, softEdge.
+*
+* ## XSD Schema
+* ```xml
+* <xsd:complexType name="CT_EffectList">
+*   <xsd:sequence>
+*     <xsd:element name="blur" type="CT_BlurEffect" minOccurs="0"/>
+*     <xsd:element name="fillOverlay" type="CT_FillOverlayEffect" minOccurs="0"/>
+*     <xsd:element name="glow" type="CT_GlowEffect" minOccurs="0"/>
+*     <xsd:element name="innerShdw" type="CT_InnerShadowEffect" minOccurs="0"/>
+*     <xsd:element name="outerShdw" type="CT_OuterShadowEffect" minOccurs="0"/>
+*     <xsd:element name="prstShdw" type="CT_PresetShadowEffect" minOccurs="0"/>
+*     <xsd:element name="reflection" type="CT_ReflectionEffect" minOccurs="0"/>
+*     <xsd:element name="softEdge" type="CT_SoftEdgesEffect" minOccurs="0"/>
+*   </xsd:sequence>
+* </xsd:complexType>
+* ```
+*/
+const createEffectList = (options) => {
+	const children = [];
+	if (options.blur) children.push(createBlurEffect$1(options.blur));
+	if (options.fillOverlay) children.push(createFillOverlayEffect(options.fillOverlay));
+	if (options.glow) children.push(createGlowEffect(options.glow));
+	if (options.innerShadow) children.push(createInnerShadowEffect(options.innerShadow));
+	if (options.outerShadow) children.push(createOuterShadowEffect(options.outerShadow));
+	if (options.presetShadow) children.push(createPresetShadowEffect(options.presetShadow));
+	if (options.reflection) children.push(createReflectionEffect(options.reflection === true ? void 0 : options.reflection));
+	if (options.softEdge !== void 0) children.push(createSoftEdgeEffect(options.softEdge));
+	return new BuilderElement({
+		children,
+		name: "a:effectLst"
+	});
+};
+//#endregion
+//#region src/drawingml/effects/effect-dag.ts
+/**
+* Effect container (effectDag) for DrawingML shapes.
+*
+* Provides CT_EffectContainer — a directed acyclic graph (DAG) of effects
+* supporting 28 effect types including alpha/color operations, nested containers,
+* and all effects from CT_EffectList.
+*
+* Reference: ISO/IEC 29500-4, dml-main.xsd, CT_EffectContainer, EG_Effect
+*
+* @module
+*/
+const buildOptionalAttributes = (options) => {
+	const attrs = {};
+	for (const [key, value] of Object.entries(options)) if (value !== void 0) attrs[key] = {
+		key,
+		value
+	};
+	return Object.keys(attrs).length > 0 ? attrs : void 0;
+};
+const createAlphaBiLevelEffect = (options) => new BuilderElement({
+	name: "a:alphaBiLevel",
+	attributes: { thresh: {
+		key: "thresh",
+		value: options.threshold
+	} }
+});
+const createAlphaCeilingEffect = () => new BuilderElement({ name: "a:alphaCeiling" });
+const createAlphaFloorEffect = () => new BuilderElement({ name: "a:alphaFloor" });
+const createAlphaInverseEffect = (options) => new BuilderElement({
+	name: "a:alphaInv",
+	children: options?.color ? [createColorElement(options.color)] : void 0
+});
+const createAlphaModulateFixedEffect = (options) => {
+	if (options?.amount === void 0) return new BuilderElement({ name: "a:alphaModFix" });
+	return new BuilderElement({
+		name: "a:alphaModFix",
+		attributes: { amt: {
+			key: "amt",
+			value: options.amount
+		} }
+	});
+};
+const createAlphaOutsetEffect = (options) => {
+	if (options?.radius === void 0) return new BuilderElement({ name: "a:alphaOutset" });
+	return new BuilderElement({
+		name: "a:alphaOutset",
+		attributes: { rad: {
+			key: "rad",
+			value: options.radius
+		} }
+	});
+};
+const createAlphaReplaceEffect = (options) => new BuilderElement({
+	name: "a:alphaRepl",
+	attributes: { a: {
+		key: "a",
+		value: options.alpha
+	} }
+});
+const createBiLevelEffect = (thresh) => new BuilderElement({
+	name: "a:biLevel",
+	attributes: { thresh: {
+		key: "thresh",
+		value: thresh
+	} }
+});
+const createBlendEffect = (options) => new BuilderElement({
+	name: "a:blend",
+	attributes: { blend: {
+		key: "blend",
+		value: xsdBlendMode.to(options.blend)
+	} },
+	children: [createEffectContainer(options.container)]
+});
+const createColorChangeEffect = (options) => {
+	const children = [new BuilderElement({
+		name: "a:clrFrom",
+		children: [createColorElement(options.from)]
+	}), new BuilderElement({
+		name: "a:clrTo",
+		children: [createColorElement(options.to)]
+	})];
+	if (options.useA === false) return new BuilderElement({
+		name: "a:clrChange",
+		attributes: { useA: {
+			key: "useA",
+			value: 0
+		} },
+		children
+	});
+	return new BuilderElement({
+		name: "a:clrChange",
+		children
+	});
+};
+const createColorReplaceEffect = (color) => new BuilderElement({
+	name: "a:clrRepl",
+	children: [createColorElement(color)]
+});
+const createDuotoneEffect = (options) => new BuilderElement({
+	name: "a:duotone",
+	children: [createColorElement(options.color1), createColorElement(options.color2)]
+});
+const createFillEffect = (options) => {
+	let fillElement;
+	if (options.noFill) fillElement = createNoFill();
+	else if (options.solidFill) fillElement = createSolidFill(options.solidFill);
+	else if (options.gradientFill) fillElement = createGradientFill(options.gradientFill);
+	else if (options.patternFill) fillElement = createPatternFill(options.patternFill);
+	else if (options.groupFill) fillElement = createGroupFill();
+	else fillElement = createNoFill();
+	return new BuilderElement({
+		name: "a:fill",
+		children: [fillElement]
+	});
+};
+const createGrayscaleEffect = () => new BuilderElement({ name: "a:grayscl" });
+const createHSLEffect = (options) => {
+	return new BuilderElement({
+		name: "a:hsl",
+		attributes: buildOptionalAttributes({
+			hue: options?.hue,
+			sat: options?.saturation,
+			lum: options?.luminance
+		})
+	});
+};
+const createLuminanceEffect = (options) => {
+	return new BuilderElement({
+		name: "a:lum",
+		attributes: buildOptionalAttributes({
+			bright: options?.bright,
+			contrast: options?.contrast
+		})
+	});
+};
+const createTintEffect = (options) => {
+	return new BuilderElement({
+		name: "a:tint",
+		attributes: buildOptionalAttributes({
+			hue: options?.hue,
+			amt: options?.amount
+		})
+	});
+};
+const createRelativeOffsetEffect = (options) => {
+	return new BuilderElement({
+		name: "a:relOff",
+		attributes: buildOptionalAttributes({
+			tx: options?.translateX,
+			ty: options?.translateY
+		})
+	});
+};
+const createTransformEffect = (options) => {
+	return new BuilderElement({
+		name: "a:xfrm",
+		attributes: buildOptionalAttributes({
+			sx: options?.scaleX,
+			sy: options?.scaleY,
+			kx: options?.skewX,
+			ky: options?.skewY,
+			tx: options?.translateX,
+			ty: options?.translateY
+		})
+	});
+};
+const createEffectReference = (options) => new BuilderElement({
+	name: "a:effect",
+	attributes: { ref: {
+		key: "ref",
+		value: options.ref
+	} }
+});
+const createBlurEffect = (options) => {
+	if (!(options.radius !== void 0 || options.grow === false)) return new BuilderElement({ name: "a:blur" });
+	return new BuilderElement({
+		attributes: {
+			...options.radius !== void 0 && { rad: {
+				key: "rad",
+				value: options.radius
+			} },
+			...options.grow === false && { grow: {
+				key: "grow",
+				value: 0
+			} }
+		},
+		name: "a:blur"
+	});
+};
+/**
+* Creates an effect container element (a:effectDag or a:cont).
+*
+* This is the CT_EffectContainer type — a recursive DAG of effects.
+* All 28 EG_Effect types are supported.
+*
+* ## XSD Schema
+* ```xml
+* <xsd:complexType name="CT_EffectContainer">
+*   <xsd:group ref="EG_Effect" minOccurs="0" maxOccurs="unbounded"/>
+*   <xsd:attribute name="type" type="ST_EffectContainerType" default="sib"/>
+*   <xsd:attribute name="name" type="xsd:token" use="optional"/>
+* </xsd:complexType>
+* ```
+*
+* @param options - Container options with effects
+* @param elementName - Element name, defaults to "a:effectDag" for top-level
+*/
+const createEffectContainer = (options, elementName = "a:cont") => {
+	const attrs = buildOptionalAttributes({
+		type: options.type ? xsdEffectContainer.to(options.type) : void 0,
+		name: options.name
+	});
+	const children = [];
+	if (options.blur) children.push(createBlurEffect(options.blur));
+	if (options.fillOverlay) children.push(createFillOverlayEffect(options.fillOverlay));
+	if (options.glow) children.push(createGlowEffect(options.glow));
+	if (options.innerShadow) children.push(createInnerShadowEffect(options.innerShadow));
+	if (options.outerShadow) children.push(createOuterShadowEffect(options.outerShadow));
+	if (options.presetShadow) children.push(createPresetShadowEffect(options.presetShadow));
+	if (options.reflection) children.push(createReflectionEffect(options.reflection === true ? void 0 : options.reflection));
+	if (options.softEdge !== void 0) children.push(createSoftEdgeEffect(options.softEdge));
+	if (options.containers) for (const nested of options.containers) children.push(createEffectContainer(nested));
+	if (options.effectRefs) for (const ref of options.effectRefs) children.push(createEffectReference(ref));
+	if (options.alphaBiLevel) children.push(createAlphaBiLevelEffect(options.alphaBiLevel));
+	if (options.alphaCeiling) children.push(createAlphaCeilingEffect());
+	if (options.alphaFloor) children.push(createAlphaFloorEffect());
+	if (options.alphaInverse) children.push(createAlphaInverseEffect(options.alphaInverse));
+	if (options.alphaModulate) children.push(new BuilderElement({
+		name: "a:alphaMod",
+		children: [createEffectContainer(options.alphaModulate)]
+	}));
+	if (options.alphaModulateFixed) children.push(createAlphaModulateFixedEffect(options.alphaModulateFixed));
+	if (options.alphaOutset) children.push(createAlphaOutsetEffect(options.alphaOutset));
+	if (options.alphaReplace) children.push(createAlphaReplaceEffect(options.alphaReplace));
+	if (options.biLevel) children.push(createBiLevelEffect(options.biLevel.threshold));
+	if (options.blend) children.push(createBlendEffect(options.blend));
+	if (options.colorChange) children.push(createColorChangeEffect(options.colorChange));
+	if (options.colorReplace) children.push(createColorReplaceEffect(options.colorReplace));
+	if (options.duotone) children.push(createDuotoneEffect(options.duotone));
+	if (options.fill) children.push(createFillEffect(options.fill));
+	if (options.grayscale) children.push(createGrayscaleEffect());
+	if (options.hsl) children.push(createHSLEffect(options.hsl));
+	if (options.luminance) children.push(createLuminanceEffect(options.luminance));
+	if (options.tint) children.push(createTintEffect(options.tint));
+	if (options.relativeOffset) children.push(createRelativeOffsetEffect(options.relativeOffset));
+	if (options.transform) children.push(createTransformEffect(options.transform));
+	return new BuilderElement({
+		name: elementName,
+		attributes: attrs,
+		children: children.length > 0 ? children : void 0
+	});
+};
+/**
+* Creates an effect DAG element (a:effectDag).
+*
+* This is the EG_EffectProperties choice alternative to effectLst,
+* supporting all 28 effect types with recursive nesting.
+*
+* @example
+* ```typescript
+* // Simple effect DAG with glow and outer shadow
+* createEffectDag({
+*   glow: { radius: 50800, color: { value: "FF0000" } },
+*   outerShadow: { color: { value: "000000" }, blurRadius: 76200 },
+* });
+*
+* // DAG with alpha effects and nested container
+* createEffectDag({
+*   type: "tree",
+*   alphaBiLevel: { threshold: 50000 },
+*   containers: [{
+*     glow: { color: { value: "FF0000" } },
+*   }],
+* });
+* ```
+*/
+const createEffectDag = (options) => createEffectContainer(options, "a:effectDag");
+//#endregion
+//#region src/drawingml/three-d/scene-3d.ts
+/**
+* 3D scene module for DrawingML shapes.
+*
+* Provides CT_Scene3D — the 3D scene properties including camera, light rig,
+* and optional backdrop that define how a 3D shape is rendered.
+*
+* Reference: ISO/IEC 29500-4, dml-main.xsd, CT_Scene3D
+*
+* @module
+*/
+const createSphereCoords = (coords) => new BuilderElement({
+	name: "a:rot",
+	attributes: {
+		lat: {
+			key: "lat",
+			value: coords.lat
+		},
+		lon: {
+			key: "lon",
+			value: coords.lon
+		},
+		rev: {
+			key: "rev",
+			value: coords.rev
+		}
+	}
+});
+const createCamera = (options) => {
+	const children = [];
+	if (options.rotation) children.push(createSphereCoords(options.rotation));
+	const attrs = { prst: {
+		key: "prst",
+		value: options.preset
+	} };
+	if (options.fov !== void 0) attrs.fov = {
+		key: "fov",
+		value: options.fov
+	};
+	if (options.zoom !== void 0) attrs.zoom = {
+		key: "zoom",
+		value: options.zoom
+	};
+	return new BuilderElement({
+		name: "a:camera",
+		attributes: attrs,
+		children: children.length > 0 ? children : void 0
+	});
+};
+const createLightRig = (options) => {
+	const children = [];
+	if (options.rotation) children.push(createSphereCoords(options.rotation));
+	return new BuilderElement({
+		name: "a:lightRig",
+		attributes: {
+			rig: {
+				key: "rig",
+				value: options.rig
+			},
+			dir: {
+				key: "dir",
+				value: options.direction
+			}
+		},
+		children: children.length > 0 ? children : void 0
+	});
+};
+const createPoint3D = (name, point) => new BuilderElement({
+	name,
+	attributes: {
+		x: {
+			key: "x",
+			value: point.x
+		},
+		y: {
+			key: "y",
+			value: point.y
+		},
+		z: {
+			key: "z",
+			value: point.z
+		}
+	}
+});
+const createVector3D = (name, vector) => new BuilderElement({
+	name,
+	attributes: {
+		dx: {
+			key: "dx",
+			value: vector.dx
+		},
+		dy: {
+			key: "dy",
+			value: vector.dy
+		},
+		dz: {
+			key: "dz",
+			value: vector.dz
+		}
+	}
+});
+const createBackdrop = (options) => new BuilderElement({
+	name: "a:backdrop",
+	children: [
+		createPoint3D("a:anchor", options.anchor),
+		createVector3D("a:norm", options.normal),
+		createVector3D("a:up", options.up)
+	]
+});
+/**
+* Creates a 3D scene element (a:scene3d).
+*
+* @example
+* ```typescript
+* // Simple scene with default camera and lighting
+* createScene3D({
+*   camera: { preset: "perspectiveFront" },
+*   lightRig: { rig: "threePt", direction: "t" },
+* });
+*
+* // Scene with rotated camera and backdrop
+* createScene3D({
+*   camera: {
+*     preset: "isometricTopUp",
+*     rotation: { lat: 0, lon: 0, rev: 5400000 },
+*   },
+*   lightRig: { rig: "balanced", direction: "tl" },
+*   backdrop: {
+*     anchor: { x: 0, y: 0, z: 0 },
+*     normal: { dx: 0, dy: 0, dz: 1 },
+*     up: { dx: 0, dy: 1, dz: 0 },
+*   },
+* });
+* ```
+*/
+const createScene3D = (options) => {
+	const children = [createCamera(options.camera), createLightRig(options.lightRig)];
+	if (options.backdrop) children.push(createBackdrop(options.backdrop));
+	return new BuilderElement({
+		name: "a:scene3d",
+		children
+	});
+};
+//#endregion
+//#region src/drawingml/three-d/bevel.ts
+/**
+* Bevel element for DrawingML 3D shapes.
+*
+* Reference: ISO/IEC 29500-4, dml-main.xsd, CT_Bevel
+*
+* @module
+*/
+/**
+* Bevel preset types (12 variations).
+*
+* Reference: ISO/IEC 29500-4, dml-main.xsd, ST_BevelPresetType
+*/
+const BevelPresetType = {
+	RELAXED_INSET: "relaxedInset",
+	CIRCLE: "circle",
+	SLOPE: "slope",
+	CROSS: "cross",
+	ANGLE: "angle",
+	SOFT_ROUND: "softRound",
+	CONVEX: "convex",
+	COOL_SLANT: "coolSlant",
+	DIVOT: "divot",
+	RIBLET: "riblet",
+	HARD_EDGE: "hardEdge",
+	ART_DECO: "artDeco"
+};
+/**
+* Creates a bevel element.
+*
+* ## XSD Schema
+* ```xml
+* <xsd:complexType name="CT_Bevel">
+*   <xsd:attribute name="w" type="ST_PositiveCoordinate" default="76200"/>
+*   <xsd:attribute name="h" type="ST_PositiveCoordinate" default="76200"/>
+*   <xsd:attribute name="prst" type="ST_BevelPresetType" default="circle"/>
+* </xsd:complexType>
+* ```
+*/
+const createBevel = (options) => {
+	if (!options) return new BuilderElement({ name: "a:bevelT" });
+	const attributes = {};
+	if (options.w !== void 0) attributes.w = {
+		key: "w",
+		value: options.w
+	};
+	if (options.h !== void 0) attributes.h = {
+		key: "h",
+		value: options.h
+	};
+	if (options.prst !== void 0) attributes.prst = {
+		key: "prst",
+		value: options.prst
+	};
+	return new BuilderElement({
+		attributes,
+		name: "a:bevelT"
+	});
+};
+/**
+* Creates a bottom bevel element (a:bevelB).
+*/
+const createBottomBevel = (options) => {
+	if (!options) return new BuilderElement({ name: "a:bevelB" });
+	const attributes = {};
+	if (options.w !== void 0) attributes.w = {
+		key: "w",
+		value: options.w
+	};
+	if (options.h !== void 0) attributes.h = {
+		key: "h",
+		value: options.h
+	};
+	if (options.prst !== void 0) attributes.prst = {
+		key: "prst",
+		value: options.prst
+	};
+	return new BuilderElement({
+		attributes,
+		name: "a:bevelB"
+	});
+};
+//#endregion
+//#region src/drawingml/three-d/shape-3d.ts
+/**
+* 3D shape properties for DrawingML.
+*
+* Reference: ISO/IEC 29500-4, dml-main.xsd, CT_Shape3D
+*
+* @module
+*/
+/**
+* Preset material types for 3D shapes (15 variations).
+*
+* Reference: ISO/IEC 29500-4, dml-main.xsd, ST_PresetMaterialType
+*/
+const PresetMaterialType = {
+	LEGACY_MATTE: "legacyMatte",
+	LEGACY_PLASTIC: "legacyPlastic",
+	LEGACY_METAL: "legacyMetal",
+	LEGACY_WIREFRAME: "legacyWireframe",
+	MATTE: "matte",
+	PLASTIC: "plastic",
+	METAL: "metal",
+	WARM_MATTE: "warmMatte",
+	TRANSLUCENT_POWDER: "translucentPowder",
+	POWDER: "powder",
+	DK_EDGE: "darkEdge",
+	SOFT_EDGE: "softEdge",
+	CLEAR: "clear",
+	FLAT: "flat",
+	SOFT_METAL: "softMetal"
+};
+/**
+* Creates a 3D shape properties element (a:sp3d).
+*
+* ## XSD Schema
+* ```xml
+* <xsd:complexType name="CT_Shape3D">
+*   <xsd:sequence>
+*     <xsd:element name="bevelT" type="CT_Bevel" minOccurs="0"/>
+*     <xsd:element name="bevelB" type="CT_Bevel" minOccurs="0"/>
+*     <xsd:element name="extrusionClr" type="CT_Color" minOccurs="0"/>
+*     <xsd:element name="contourClr" type="CT_Color" minOccurs="0"/>
+*   </xsd:sequence>
+*   <xsd:attribute name="z" type="ST_Coordinate" default="0"/>
+*   <xsd:attribute name="extrusionH" type="ST_PositiveCoordinate" default="0"/>
+*   <xsd:attribute name="contourW" type="ST_PositiveCoordinate" default="0"/>
+*   <xsd:attribute name="prstMaterial" type="ST_PresetMaterialType" default="warmMatte"/>
+* </xsd:complexType>
+* ```
+*/
+const createShape3D = (options) => {
+	const children = [];
+	if (options.bevelT) children.push(createBevel(options.bevelT));
+	if (options.bevelB) children.push(createBottomBevel(options.bevelB));
+	if (options.extrusionColor) children.push(new BuilderElement({
+		children: [createColorElement(options.extrusionColor)],
+		name: "a:extrusionClr"
+	}));
+	if (options.contourColor) children.push(new BuilderElement({
+		children: [createColorElement(options.contourColor)],
+		name: "a:contourClr"
+	}));
+	return new BuilderElement({
+		attributes: options.z !== void 0 || options.extrusionH !== void 0 || options.contourW !== void 0 || options.prstMaterial !== void 0 ? {
+			...options.z !== void 0 && { z: {
+				key: "z",
+				value: options.z
+			} },
+			...options.extrusionH !== void 0 && { extrusionH: {
+				key: "extrusionH",
+				value: options.extrusionH
+			} },
+			...options.contourW !== void 0 && { contourW: {
+				key: "contourW",
+				value: options.contourW
+			} },
+			...options.prstMaterial !== void 0 && { prstMaterial: {
+				key: "prstMaterial",
+				value: xsdMaterialType.to(options.prstMaterial)
+			} }
+		} : void 0,
+		children,
+		name: "a:sp3d"
+	});
+};
+//#endregion
+//#region src/drawingml/geometry/adjustment-values.ts
+/**
+* Adjustment values module for preset geometries.
+*
+* This module provides adjustment value lists that can modify the appearance
+* of preset shape geometries.
+*
+* Reference: ISO/IEC 29500-4, dml-main.xsd, CT_GeomGuideList, CT_GeomGuide
+*
+* @module
+*/
+/**
+* Creates an adjustment values list element (a:avLst).
+*
+* The adjustment values list contains geometry guides that modify
+* the appearance of a preset geometric shape. When empty, default
+* values are used.
+*
+* ## XSD Schema
+* ```xml
+* <xsd:complexType name="CT_GeomGuideList">
+*   <xsd:sequence>
+*     <xsd:element name="gd" type="CT_GeomGuide" minOccurs="0" maxOccurs="unbounded"/>
+*   </xsd:sequence>
+* </xsd:complexType>
+* ```
+*
+* @example
+* ```typescript
+* // Empty adjustment values (defaults)
+* createAdjustmentValues();
+*
+* // With guides
+* createAdjustmentValues([
+*   { name: "adj", formula: "val 16667" },
+* ]);
+* ```
+*/
+const createAdjustmentValues = (guides) => {
+	const children = [];
+	if (guides) for (const guide of guides) children.push(new BuilderElement({
+		attributes: {
+			name: {
+				key: "name",
+				value: guide.name
+			},
+			fmla: {
+				key: "fmla",
+				value: guide.formula
+			}
+		},
+		name: "a:gd"
+	}));
+	return new BuilderElement({
+		children,
+		name: "a:avLst"
+	});
+};
+//#endregion
+//#region src/drawingml/geometry/preset-geometry.ts
+/**
+* Preset geometry module for DrawingML shapes.
+*
+* This module provides predefined shape geometries that can be applied
+* to pictures and shapes without requiring custom path definitions.
+*
+* Reference: ISO/IEC 29500-4, dml-main.xsd, CT_PresetGeometry2D
+*
+* @module
+*/
+/**
+* Represents a preset geometry for a DrawingML shape.
+*
+* This element specifies when a preset geometric shape should be used instead
+* of a custom geometry. It includes a shape preset identifier and optional
+* adjustment values that modify the base shape.
+*
+* ## XSD Schema
+* ```xml
+* <xsd:complexType name="CT_PresetGeometry2D">
+*   <xsd:sequence>
+*     <xsd:element name="avLst" type="CT_GeomGuideList" minOccurs="0" maxOccurs="1"/>
+*   </xsd:sequence>
+*   <xsd:attribute name="prst" type="ST_ShapeType" use="required"/>
+* </xsd:complexType>
+* ```
+*
+* @example
+* ```typescript
+* // Default rectangle
+* const geometry = new PresetGeometry();
+*
+* // Rounded rectangle with adjustment
+* const geometry = new PresetGeometry({
+*   preset: "roundRect",
+*   adjustmentValues: [{ name: "adj", formula: "val 16667" }],
+* });
+* ```
+*/
+var PresetGeometry = class extends XmlComponent {
+	constructor(options) {
+		super("a:prstGeom");
+		this.root.push({ _attr: { prst: options?.preset ?? "rect" } });
+		this.root.push(createAdjustmentValues(options?.adjustmentValues));
+	}
+};
+//#endregion
+//#region src/drawingml/geometry/custom-geometry.ts
+/**
+* Custom geometry module for DrawingML shapes.
+*
+* Provides CT_CustomGeometry2D — user-defined 2D geometry with paths,
+* guides, adjust handles, connection sites, and a text insertion rectangle.
+*
+* Reference: ISO/IEC 29500-4, dml-main.xsd, CT_CustomGeometry2D
+*
+* @module
+*/
+/**
+* Creates a geometry guide list element (a:avLst or a:gdLst).
+*
+* Both CT_GeomGuideList types share the same structure — a list of `a:gd` children.
+* The only difference is the wrapper element name.
+*/
+const createGuideList = (name, guides) => {
+	return new BuilderElement({
+		name,
+		children: guides.map((guide) => new BuilderElement({
+			attributes: {
+				name: {
+					key: "name",
+					value: guide.name
+				},
+				fmla: {
+					key: "fmla",
+					value: guide.formula
+				}
+			},
+			name: "a:gd"
+		}))
+	});
+};
+const createAdjPoint = (name, point) => new BuilderElement({
+	name,
+	children: [new BuilderElement({
+		name: "a:pt",
+		attributes: {
+			x: {
+				key: "x",
+				value: point.x
+			},
+			y: {
+				key: "y",
+				value: point.y
+			}
+		}
+	})]
+});
+const createPathCommand = (cmd) => {
+	switch (cmd.command) {
+		case "moveTo": return createAdjPoint("a:moveTo", cmd.point);
+		case "lineTo": return createAdjPoint("a:lnTo", cmd.point);
+		case "arcTo": return new BuilderElement({
+			name: "a:arcTo",
+			attributes: {
+				wR: {
+					key: "wR",
+					value: cmd.widthRadius
+				},
+				hR: {
+					key: "hR",
+					value: cmd.heightRadius
+				},
+				stAng: {
+					key: "stAng",
+					value: cmd.startAngle
+				},
+				swAng: {
+					key: "swAng",
+					value: cmd.sweepAngle
+				}
+			}
+		});
+		case "quadBezTo": return new BuilderElement({
+			name: "a:quadBezTo",
+			children: cmd.points.map((pt) => new BuilderElement({
+				name: "a:pt",
+				attributes: {
+					x: {
+						key: "x",
+						value: pt.x
+					},
+					y: {
+						key: "y",
+						value: pt.y
+					}
+				}
+			}))
+		});
+		case "cubicBezTo": return new BuilderElement({
+			name: "a:cubicBezTo",
+			children: cmd.points.map((pt) => new BuilderElement({
+				name: "a:pt",
+				attributes: {
+					x: {
+						key: "x",
+						value: pt.x
+					},
+					y: {
+						key: "y",
+						value: pt.y
+					}
+				}
+			}))
+		});
+		case "close": return new BuilderElement({ name: "a:close" });
+	}
+};
+const createPath = (options) => {
+	const attrs = {};
+	if (options.w !== void 0) attrs.w = {
+		key: "w",
+		value: options.w
+	};
+	if (options.h !== void 0) attrs.h = {
+		key: "h",
+		value: options.h
+	};
+	if (options.fill !== void 0) attrs.fill = {
+		key: "fill",
+		value: xsdPathFillMode.to(options.fill)
+	};
+	if (options.stroke !== void 0) attrs.stroke = {
+		key: "stroke",
+		value: options.stroke
+	};
+	if (options.extrusionOk !== void 0) attrs.extrusionOk = {
+		key: "extrusionOk",
+		value: options.extrusionOk
+	};
+	return new BuilderElement({
+		name: "a:path",
+		attributes: Object.keys(attrs).length > 0 ? attrs : void 0,
+		children: options.commands.map(createPathCommand)
+	});
+};
+const createAdjustHandlePos = (position) => new BuilderElement({
+	name: "a:pos",
+	attributes: {
+		x: {
+			key: "x",
+			value: position.x
+		},
+		y: {
+			key: "y",
+			value: position.y
+		}
+	}
+});
+const createXYAdjustHandle = (handle) => {
+	const attrs = {};
+	if (handle.guideRefX !== void 0) attrs.gdRefX = {
+		key: "gdRefX",
+		value: handle.guideRefX
+	};
+	if (handle.minX !== void 0) attrs.minX = {
+		key: "minX",
+		value: handle.minX
+	};
+	if (handle.maxX !== void 0) attrs.maxX = {
+		key: "maxX",
+		value: handle.maxX
+	};
+	if (handle.guideRefY !== void 0) attrs.gdRefY = {
+		key: "gdRefY",
+		value: handle.guideRefY
+	};
+	if (handle.minY !== void 0) attrs.minY = {
+		key: "minY",
+		value: handle.minY
+	};
+	if (handle.maxY !== void 0) attrs.maxY = {
+		key: "maxY",
+		value: handle.maxY
+	};
+	return new BuilderElement({
+		name: "a:ahXY",
+		attributes: Object.keys(attrs).length > 0 ? attrs : void 0,
+		children: [createAdjustHandlePos(handle.position)]
+	});
+};
+const createPolarAdjustHandle = (handle) => {
+	const attrs = {};
+	if (handle.guideRefRadius !== void 0) attrs.gdRefR = {
+		key: "gdRefR",
+		value: handle.guideRefRadius
+	};
+	if (handle.minRadius !== void 0) attrs.minR = {
+		key: "minR",
+		value: handle.minRadius
+	};
+	if (handle.maxRadius !== void 0) attrs.maxR = {
+		key: "maxR",
+		value: handle.maxRadius
+	};
+	if (handle.guideRefAngle !== void 0) attrs.gdRefAng = {
+		key: "gdRefAng",
+		value: handle.guideRefAngle
+	};
+	if (handle.minAngle !== void 0) attrs.minAng = {
+		key: "minAng",
+		value: handle.minAngle
+	};
+	if (handle.maxAngle !== void 0) attrs.maxAng = {
+		key: "maxAng",
+		value: handle.maxAngle
+	};
+	return new BuilderElement({
+		name: "a:ahPolar",
+		attributes: Object.keys(attrs).length > 0 ? attrs : void 0,
+		children: [createAdjustHandlePos(handle.position)]
+	});
+};
+const createConnectionSite = (site) => new BuilderElement({
+	name: "a:cxn",
+	attributes: { ang: {
+		key: "ang",
+		value: site.angle
+	} },
+	children: [createAdjustHandlePos(site.position)]
+});
+const createGeomRect = (rect) => new BuilderElement({
+	name: "a:rect",
+	attributes: {
+		l: {
+			key: "l",
+			value: rect.left
+		},
+		t: {
+			key: "t",
+			value: rect.top
+		},
+		r: {
+			key: "r",
+			value: rect.right
+		},
+		b: {
+			key: "b",
+			value: rect.bottom
+		}
+	}
+});
+/**
+* Creates a custom 2D geometry element (a:custGeom).
+*
+* @example
+* ```typescript
+* // Diamond shape
+* const geom = createCustomGeometry({
+*   pathList: [{
+*     commands: [
+*       { command: "moveTo", point: { x: "5000000", y: "0" } },
+*       { command: "lineTo", point: { x: "10000000", y: "5000000" } },
+*       { command: "lineTo", point: { x: "5000000", y: "10000000" } },
+*       { command: "lineTo", point: { x: "0", y: "5000000" } },
+*       { command: "close" },
+*     ],
+*   }],
+*   textRect: { left: "2000000", top: "2000000", right: "8000000", bottom: "8000000" },
+* });
+* ```
+*/
+const createCustomGeometry = (options) => {
+	const children = [];
+	if (options.adjustmentValues) children.push(createGuideList("a:avLst", options.adjustmentValues));
+	if (options.guides) children.push(createGuideList("a:gdLst", options.guides));
+	if (options.adjustHandles && options.adjustHandles.length > 0) children.push(new BuilderElement({
+		name: "a:ahLst",
+		children: options.adjustHandles.map((h) => h.type === "xy" ? createXYAdjustHandle(h) : createPolarAdjustHandle(h))
+	}));
+	if (options.connectionSites && options.connectionSites.length > 0) children.push(new BuilderElement({
+		name: "a:cxnLst",
+		children: options.connectionSites.map(createConnectionSite)
+	}));
+	if (options.textRect) children.push(createGeomRect(options.textRect));
+	children.push(new BuilderElement({
+		name: "a:pathLst",
+		children: options.pathList.map(createPath)
+	}));
+	return new BuilderElement({
+		name: "a:custGeom",
+		children
+	});
+};
+//#endregion
+//#region src/drawingml/blip/blip-extentions.ts
+/**
+* Blip extensions module for SVG support.
+*
+* This module provides extension elements that enable SVG image support
+* within blip elements using Office-specific extensions.
+*
+* Reference: http://officeopenxml.com/drwPic.php
+*
+* @module
+*/
+/**
+* Creates an SVG blip element for embedding SVG images.
+*
+* This element is a Microsoft Office extension that allows SVG images
+* to be referenced within a blip.
+*
+* @param svgReferenceId - The reference ID for the SVG image
+* @returns An XML component representing the SVG blip element
+* @internal
+*/
+const createSvgBlip = (svgReferenceId) => new BuilderElement({
+	attributes: {
+		asvg: {
+			key: "xmlns:asvg",
+			value: "http://schemas.microsoft.com/office/drawing/2016/SVG/main"
+		},
+		embed: {
+			key: "r:embed",
+			value: `{${svgReferenceId}}`
+		}
+	},
+	name: "asvg:svgBlip"
+});
+/**
+* Creates an extension element for SVG support.
+*
+* This element wraps the SVG blip extension with the appropriate URI
+* to identify it as an SVG extension.
+*
+* @param svgReferenceId - The reference ID for the SVG image
+* @returns An XML component representing the extension element
+* @internal
+*/
+const createExtention = (svgReferenceId) => new BuilderElement({
+	attributes: { uri: {
+		key: "uri",
+		value: "{96DAC541-7B7A-43D3-8B79-37D633B846F1}"
+	} },
+	children: [createSvgBlip(svgReferenceId)],
+	name: "a:ext"
+});
+/**
+* Creates an extension list for SVG images.
+*
+* This element contains the extensions needed to embed SVG images
+* within a blip. It wraps the SVG-specific extension elements.
+*
+* ## XSD Schema
+* ```xml
+* <xsd:complexType name="CT_OfficeArtExtensionList">
+*   <xsd:sequence>
+*     <xsd:element name="ext" type="CT_OfficeArtExtension" minOccurs="0" maxOccurs="unbounded"/>
+*   </xsd:sequence>
+* </xsd:complexType>
+* ```
+*
+* @param svgReferenceId - The reference ID for the SVG image
+* @returns An XML component representing the extension list
+*/
+const createExtentionList = (svgReferenceId) => new BuilderElement({
+	children: [createExtention(svgReferenceId)],
+	name: "a:extLst"
+});
+//#endregion
+//#region src/drawingml/blip/blip.ts
+/**
+* Blip (Binary Large Image or Picture) module for DrawingML.
+*
+* This module provides the blip element that references the actual
+* image data within a picture.
+*
+* Reference: http://officeopenxml.com/drwPic.php
+*
+* @module
+*/
+/**
+* Creates a blip element for an image.
+*
+* A blip references the actual image data stored in the document package
+* through a relationship ID. For SVG images, it includes extensions that
+* reference the SVG data.
+*
+* Reference: http://officeopenxml.com/drwPic.php
+*
+* ## XSD Schema
+* ```xml
+* <xsd:complexType name="CT_Blip">
+*   <xsd:sequence>
+*     <xsd:choice minOccurs="0" maxOccurs="unbounded">
+*       <xsd:element name="alphaBiLevel" type="CT_AlphaBiLevelEffect"/>
+*       <xsd:element name="alphaCeiling" type="CT_AlphaCeilingEffect"/>
+*       <xsd:element name="alphaFloor" type="CT_AlphaFloorEffect"/>
+*       <xsd:element name="alphaInv" type="CT_AlphaInverseEffect"/>
+*       <xsd:element name="alphaMod" type="CT_AlphaModulateEffect"/>
+*       <xsd:element name="alphaModFix" type="CT_AlphaModulateFixedEffect"/>
+*       <xsd:element name="alphaRepl" type="CT_AlphaReplaceEffect"/>
+*       <xsd:element name="biLevel" type="CT_BiLevelEffect"/>
+*       <xsd:element name="blur" type="CT_BlurEffect"/>
+*       <xsd:element name="clrChange" type="CT_ColorChangeEffect"/>
+*       <xsd:element name="clrRepl" type="CT_ColorReplaceEffect"/>
+*       <xsd:element name="duotone" type="CT_DuotoneEffect"/>
+*       <xsd:element name="fillOverlay" type="CT_FillOverlayEffect"/>
+*       <xsd:element name="grayscl" type="CT_GrayscaleEffect"/>
+*       <xsd:element name="hsl" type="CT_HSLEffect"/>
+*       <xsd:element name="lum" type="CT_LuminanceEffect"/>
+*       <xsd:element name="tint" type="CT_TintEffect"/>
+*     </xsd:choice>
+*     <xsd:element name="extLst" type="CT_OfficeArtExtensionList" minOccurs="0"/>
+*   </xsd:sequence>
+*   <xsd:attribute ref="r:embed"/>
+*   <xsd:attribute ref="r:link"/>
+*   <xsd:attribute name="cstate" type="ST_BlipCompression"/>
+* </xsd:complexType>
+* ```
+*
+* @param options - Blip options including referenceId and type
+* @param blipEffects - Optional blip effects (brightness, contrast, etc.)
+* @returns An XML component representing the blip element
+*/
+const createBlip = (options, blipEffects) => {
+	const children = [];
+	if (blipEffects) children.push(...createBlipEffects(blipEffects));
+	if (options.type === "svg" && options.fallbackFileName) children.push(createExtentionList(options.referenceId));
+	return new BuilderElement({
+		attributes: {
+			cstate: {
+				key: "cstate",
+				value: "none"
+			},
+			embed: {
+				key: "r:embed",
+				value: `{${options.type === "svg" && options.fallbackFileName ? options.fallbackFileName : options.referenceId}}`
+			}
+		},
+		children,
+		name: "a:blip"
+	});
+};
+//#endregion
+//#region src/drawingml/blip/blip-fill.ts
+/**
+* Blip fill module for DrawingML pictures.
+*
+* This module defines how an image (blip) fills a picture shape,
+* including stretching and cropping options.
+*
+* Reference: ISO/IEC 29500-4, dml-main.xsd, CT_BlipFillProperties
+*
+* @module
+*/
+/**
+* Creates a blip fill element.
+*
+* This element specifies the type of fill used for a picture. It contains the blip (image)
+* reference, an optional source rectangle for cropping, and the fill mode (typically stretch).
+*
+* Reference: ISO/IEC 29500-4, dml-main.xsd, CT_BlipFillProperties
+*
+* ## XSD Schema
+* ```xml
+* <xsd:complexType name="CT_BlipFillProperties">
+*   <xsd:sequence>
+*     <xsd:element name="blip" type="CT_Blip" minOccurs="0" maxOccurs="1"/>
+*     <xsd:element name="srcRect" type="CT_RelativeRect" minOccurs="0" maxOccurs="1"/>
+*     <xsd:group ref="EG_FillModeProperties" minOccurs="0" maxOccurs="1"/>
+*   </xsd:sequence>
+*   <xsd:attribute name="dpi" type="xsd:unsignedInt" use="optional"/>
+*   <xsd:attribute name="rotWithShape" type="xsd:boolean" use="optional"/>
+* </xsd:complexType>
+* ```
+*
+* @param blipOptions - Blip options including referenceId and type
+* @param fillOptions - Optional blip fill options
+*/
+const createBlipFill = (blipOptions, fillOptions) => {
+	const children = [];
+	children.push(createBlip(blipOptions, fillOptions?.blipEffects));
+	children.push(createSourceRectangle(fillOptions?.srcRect));
+	if (fillOptions?.tile) children.push(createTileInfo(fillOptions.tile));
+	else children.push(new Stretch());
+	const attributes = {};
+	if (fillOptions?.dpi !== void 0) attributes.dpi = {
+		key: "dpi",
+		value: fillOptions.dpi
+	};
+	if (fillOptions?.rotWithShape !== void 0) attributes.rotWithShape = {
+		key: "rotWithShape",
+		value: fillOptions.rotWithShape ? 1 : 0
+	};
+	return new BuilderElement({
+		attributes: Object.keys(attributes).length > 0 ? attributes : void 0,
+		children,
+		name: "pic:blipFill"
+	});
+};
+//#endregion
+//#region src/drawingml/transform.ts
+/**
+* 2D transform for DrawingML shapes.
+*
+* This module provides factory functions for creating transform elements
+* (a:xfrm) used in shape properties, picture properties, and group shapes.
+*
+* Reference: ISO/IEC 29500-4, dml-main.xsd, CT_Transform2D / CT_GroupTransform2D
+*
+* @module
+*/
+function buildXfrmAttrs(options) {
+	const attrs = {};
+	if (options.flipHorizontal !== void 0) attrs.flipH = {
+		key: "flipH",
+		value: options.flipHorizontal
+	};
+	if (options.flipVertical !== void 0) attrs.flipV = {
+		key: "flipV",
+		value: options.flipVertical
+	};
+	if (options.rotation !== void 0) attrs.rot = {
+		key: "rot",
+		value: options.rotation
+	};
+	return Object.keys(attrs).length > 0 ? attrs : void 0;
+}
+/**
+* Creates a 2D transform element (a:xfrm).
+*
+* @param options - Transform options including position, size, rotation, and flip.
+* @param elementName - Element name, defaults to "a:xfrm".
+*/
+const createTransform2D = (options, elementName = "a:xfrm") => {
+	const children = [];
+	if (options.x !== void 0 || options.y !== void 0) children.push(new BuilderElement({
+		name: "a:off",
+		attributes: {
+			x: {
+				key: "x",
+				value: options.x ?? 0
+			},
+			y: {
+				key: "y",
+				value: options.y ?? 0
+			}
+		}
+	}));
+	if (options.width !== void 0 || options.height !== void 0) children.push(new BuilderElement({
+		name: "a:ext",
+		attributes: {
+			cx: {
+				key: "cx",
+				value: options.width ?? 0
+			},
+			cy: {
+				key: "cy",
+				value: options.height ?? 0
+			}
+		}
+	}));
+	return new BuilderElement({
+		name: elementName,
+		attributes: buildXfrmAttrs(options),
+		children: children.length > 0 ? children : void 0
+	});
+};
+/**
+* Creates a group transform element (a:xfrm with chOff/chExt children).
+*/
+const createGroupTransform2D = (options, elementName = "a:xfrm") => {
+	const base = createTransform2D(options, elementName);
+	base["root"].push(new BuilderElement({
+		name: "a:chOff",
+		attributes: {
+			x: {
+				key: "x",
+				value: options.childOffsetX ?? 0
+			},
+			y: {
+				key: "y",
+				value: options.childOffsetY ?? 0
+			}
+		}
+	}));
+	base["root"].push(new BuilderElement({
+		name: "a:chExt",
+		attributes: {
+			cx: {
+				key: "cx",
+				value: options.childExtentWidth ?? 0
+			},
+			cy: {
+				key: "cy",
+				value: options.childExtentHeight ?? 0
+			}
+		}
+	}));
+	return base;
+};
+//#endregion
+//#region src/drawingml/media/transformation.ts
+/**
+* Media transformation utilities for DrawingML.
+*
+* Converts user-facing transformation options (pixels) to internal
+* transformation data (pixels + EMUs).
+*
+* @module
+*/
+/**
+* Converts user-facing transformation options (pixels) to internal
+* transformation data (pixels + EMUs).
+*
+* @param options - User-facing transformation in pixels
+* @returns Internal transformation data with both pixel and EMU values
+*/
+const createTransformation = (options) => ({
+	emus: {
+		x: convertPixelsToEmu(options.width),
+		y: convertPixelsToEmu(options.height)
+	},
+	flip: options.flip,
+	offset: {
+		emus: {
+			x: convertPixelsToEmu(options.offset?.left ?? 0),
+			y: convertPixelsToEmu(options.offset?.top ?? 0)
+		},
+		pixels: {
+			x: Math.round(options.offset?.left ?? 0),
+			y: Math.round(options.offset?.top ?? 0)
+		}
+	},
+	pixels: {
+		x: Math.round(options.width),
+		y: Math.round(options.height)
+	},
+	rotation: options.rotation ? options.rotation * 6e4 : void 0
+});
+//#endregion
+export { xsdCompoundLine as $, LineJoin as A, hashedId as At, createNoFill as B, convertPixelsToEmu as Bt, createOuterShadowEffect as C, createSchemeColor as Ct, createFillOverlayEffect as D, createPresetColor as Dt, BlendMode as E, PresetColor as Et, LineEndType as F, convertEmuToPixels as Ft, PathShadeType as G, extractBlipFillMedia as H, LineEndWidth as I, convertEmuToPoints as It, createGradientStop as J, TileFlipMode as K, createLineEnd as L, convertInchesToEmu as Lt, PresetDash as M, uniqueNumericIdCreator as Mt, createOutline as N, uniqueUuid as Nt, CompoundLine as O, createHslColor as Ot, LineEndLength as P, convertEmuToInches as Pt, xsdBlendMode as Q, createCustomDash as R, convertInchesToTwip as Rt, RectAlignment as S, SchemeColor as St, createGlowEffect as T, createRgbColor as Tt, PresetPattern as U, buildFill as V, convertPointsToEmu as Vt, createPatternFill as W, createTileInfo as X, TileAlignment as Y, invertMap as Z, createEffectList as _, createBlipEffects as _t, createBlip as a, xsdPattern as at, PresetShadowVal as b, SystemColor as bt, PresetGeometry as c, xsdRectAlignment as ct, createShape3D as d, xsdTextAnchor as dt, xsdEffectContainer as et, BevelPresetType as f, xsdTextCaps as ft, createEffectDag as g, createSourceRectangle as gt, createScene3D as h, Stretch as ht, createBlipFill as i, xsdPathFillMode as it, PenAlignment as j, uniqueId as jt, LineCap as k, createColorTransforms as kt, createAdjustmentValues as l, xsdStrikeStyle as lt, createBottomBevel as m, xsdVerticalMergeRev as mt, createGroupTransform2D as n, xsdLineEndSize as nt, createExtentionList as o, xsdPenAlignment as ot, createBevel as p, xsdUnderlineStyle as pt, createGradientFill as q, createTransform2D as r, xsdMaterialType as rt, createCustomGeometry as s, xsdPresetShadow as st, createTransformation as t, xsdLineCap as tt, PresetMaterialType as u, xsdTextAlign as ut, createSoftEdgeEffect as v, createColorElement as vt, createInnerShadowEffect as w, createScRgbColor as wt, createPresetShadowEffect as x, createSystemColor as xt, createReflectionEffect as y, createSolidFill as yt, createGroupFill as z, convertMillimetersToTwip as zt };