@office-open/core 0.11.0 → 0.12.0

package/dist/{generators-CElPsAhd.mjs → ext-uri-BHBcIrW7.mjs}

@@ -170,7 +170,8 @@ const positiveUniversalMeasureValue = (val) => {
 */
 const hexColorValue = (val) => {
 	if (val === "auto") return val;
-	return hexBinary(stripColorHashPrefix(val), 3);
+	const color = stripColorHashPrefix(val);
+	return hexBinary(color, 3);
 };
 /**
 * Strips the leading "#" prefix from a color string if present.
@@ -212,8 +213,8 @@ const parseOnOff = (raw) => {
 	if (raw === void 0) return void 0;
 	if (typeof raw === "boolean") return raw;
 	const s = String(raw).toLowerCase();
-	if (s === "1" || s === "true" || s === "on") return true;
-	if (s === "0" || s === "false" || s === "off") return false;
+	if (s === "1" || s === "true" || s === "on" || s === "t") return true;
+	if (s === "0" || s === "false" || s === "off" || s === "f") return false;
 };
 /**
 * Validates a signed TWIP measurement value.
@@ -369,49 +370,6 @@ const pointMeasureValue = unsignedDecimalNumber;
 * ```
 */
 const dateTimeValue = (val) => val.toISOString();
-/**
-* Theme color values used throughout OOXML for referencing document theme colors.
-*
-* Reference: ST_ThemeColor in OOXML specification
-*
-* @publicApi
-*/
-const ThemeColor = {
-	DARK1: "dark1",
-	LIGHT1: "light1",
-	DARK2: "dark2",
-	LIGHT2: "light2",
-	ACCENT1: "accent1",
-	ACCENT2: "accent2",
-	ACCENT3: "accent3",
-	ACCENT4: "accent4",
-	ACCENT5: "accent5",
-	ACCENT6: "accent6",
-	HYPERLINK: "hyperlink",
-	FOLLOWED_HYPERLINK: "followedHyperlink",
-	NONE: "none",
-	BACKGROUND1: "background1",
-	TEXT1: "text1",
-	BACKGROUND2: "background2",
-	TEXT2: "text2"
-};
-/**
-* Theme font values used for referencing document theme fonts.
-*
-* Reference: ST_Theme in OOXML specification
-*
-* @publicApi
-*/
-const ThemeFont = {
-	MAJOR_EAST_ASIA: "majorEastAsia",
-	MAJOR_BIDI: "majorBidi",
-	MAJOR_ASCII: "majorAscii",
-	MAJOR_H_ANSI: "majorHAnsi",
-	MINOR_EAST_ASIA: "minorEastAsia",
-	MINOR_BIDI: "minorBidi",
-	MINOR_ASCII: "minorAscii",
-	MINOR_H_ANSI: "minorHAnsi"
-};
 //#endregion
 //#region \0polyfill-node.global.js
 var _polyfill_node_global_default = typeof _polyfill_node_global_default !== "undefined" ? _polyfill_node_global_default : typeof self !== "undefined" ? self : typeof window !== "undefined" ? window : {};
@@ -936,18 +894,23 @@ function bidirectionalIndexOf(buffer, val, byteOffset, encoding, dir) {
 	byteOffset = +byteOffset;
 	if (isNaN(byteOffset)) byteOffset = dir ? 0 : buffer.length - 1;
 	if (byteOffset < 0) byteOffset = buffer.length + byteOffset;
-	if (byteOffset >= buffer.length) if (dir) return -1;
-	else byteOffset = buffer.length - 1;
-	else if (byteOffset < 0) if (dir) byteOffset = 0;
-	else return -1;
+	if (byteOffset >= buffer.length) {
+		if (dir) return -1;
+		else byteOffset = buffer.length - 1;
+	} else if (byteOffset < 0) {
+		if (dir) byteOffset = 0;
+		else return -1;
+	}
 	if (typeof val === "string") val = Buffer.from(val, encoding);
 	if (internalIsBuffer(val)) {
 		if (val.length === 0) return -1;
 		return arrayIndexOf(buffer, val, byteOffset, encoding, dir);
 	} else if (typeof val === "number") {
 		val = val & 255;
-		if (Buffer.TYPED_ARRAY_SUPPORT && typeof Uint8Array.prototype.indexOf === "function") if (dir) return Uint8Array.prototype.indexOf.call(buffer, val, byteOffset);
-		else return Uint8Array.prototype.lastIndexOf.call(buffer, val, byteOffset);
+		if (Buffer.TYPED_ARRAY_SUPPORT && typeof Uint8Array.prototype.indexOf === "function") {
+			if (dir) return Uint8Array.prototype.indexOf.call(buffer, val, byteOffset);
+			else return Uint8Array.prototype.lastIndexOf.call(buffer, val, byteOffset);
+		}
 		return arrayIndexOf(buffer, [val], byteOffset, encoding, dir);
 	}
 	throw new TypeError("val must be string, number or Buffer");
@@ -1707,275 +1670,67 @@ function encodeBase64(bytes) {
 	return btoa(binary);
 }
 //#endregion
-//#region src/util/converters.ts
+//#region src/util/data-type.ts
 /**
-* Apply `fn` to `value` unless it is `undefined`; `undefined` passes through.
+* Binary input normalization.
 *
-* Lets an optional field (e.g. `radius?: number | UniversalMeasure`) be threaded
-* through a conversion without a per-call ternary.
-*/
-const mapOptional = (value, fn) => value === void 0 ? void 0 : fn(value);
-/**
-* Convert public percent (100 = 100%) to OOXML ST_Percentage scalar (1/1000).
-* Math.round ensures JSON-first float input produces exact integer output.
-*/
-const emitPercent = (percent) => Math.round(percent * 1e3);
-/**
-* Convert OOXML ST_Percentage scalar (1/1000) to public percent.
-*/
-const parsePercent = (value) => value / 1e3;
-/**
-* Convert public degrees to OOXML ST_Angle / ST_FixedAngle scalar (1/60000).
-* Math.round ensures JSON-first float input produces exact integer output.
-*/
-const emitAngle = (degrees) => Math.round(degrees * 6e4);
-/**
-* Convert OOXML ST_Angle / ST_FixedAngle scalar (1/60000) to public degrees.
-*/
-const parseAngle = (value) => value / 6e4;
-/**
-* 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).
+* Accepts the full range of binary inputs (Buffer/Uint8Array/ArrayBuffer/
+* DataView/number[]/string/base64 data URL/…) and normalizes to `Uint8Array`.
+* Centralized here so every entry point (packer, patch, descriptor helpers)
+* shares one definition instead of re-declaring per module.
 *
-* Returns a possibly fractional (sub-pixel) value. The integer rounding that
-* lived here before permanently discarded sub-pixel precision, which made an
-* EMU → pixel → EMU round-trip lossy (e.g. 5521960 EMU → 580 px → 5524500 EMU).
-* Keeping the fraction lets convertPixelsToEmu restore the exact original EMU.
-* Callers needing an integer pixel for display should Math.round the result.
-*/
-const convertEmuToPixels = (emus) => 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.
+* @module
 */
-const convertEmuToPoints = (emus) => emus / 12700;
-/** Converts EMU to TWIP (1 TWIP = 635 EMU). */
-const convertEmuToTwip = (emus) => Math.round(emus / 635);
-/** Converts TWIP to EMU (1 TWIP = 635 EMU). */
-const convertTwipToEmu = (twips) => twips * 635;
-/** Converts points to TWIP (1 point = 20 TWIP). */
-const convertPointsToTwip = (points) => Math.round(points * 20);
-/** Converts TWIP to points (1 point = 20 TWIP). */
-const convertTwipToPoints = (twips) => twips / 20;
+const DATA_URL_RE = /^data:([\w.+-]+\/[\w.+-]+)?;base64,/;
+/** Test whether a string is a base64 data URL (`data:[mime];base64,...`). */
+function isBase64DataURL(input) {
+	return DATA_URL_RE.test(input);
+}
+/** Normalize any supported binary input to a `Uint8Array`. */
+function toUint8Array(data, options) {
+	if (data instanceof Uint8Array) return data;
+	if (data instanceof ArrayBuffer) return new Uint8Array(data);
+	if (data instanceof DataView) return new Uint8Array(data.buffer, data.byteOffset, data.byteLength);
+	if (typeof data === "string") {
+		const match = data.match(DATA_URL_RE);
+		if (match) return decodeBase64(data.slice(match[0].length));
+		if (options?.encoding === "base64") return decodeBase64(data);
+		return new TextEncoder().encode(data);
+	}
+	if (Array.isArray(data)) return new Uint8Array(data);
+	if (data instanceof Blob) throw new TypeError("Blob input requires async processing");
+	if (data instanceof ReadableStream) throw new TypeError("ReadableStream input requires async processing");
+	throw new TypeError(`Unsupported data type: ${typeof data}`);
+}
+//#endregion
+//#region src/util/mappings.ts
 /**
-* Parse a UniversalMeasure string into its numeric value and unit.
+* Bidirectional mappings between user-friendly values and XSD abbreviated values.
 *
-* @param measure - A universal measure string like "2.54cm", "-10mm", "1in"
-* @returns The parsed value and unit
-* @throws Error if the format is invalid
+* 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.
 *
-* @example
-* ```typescript
-* parseUniversalMeasure("2.54cm"); // { value: 2.54, unit: "cm" }
-* parseUniversalMeasure("-10mm");  // { value: -10, unit: "mm" }
-* ```
+* Usage in generation (Options → XML):  xsdAlign.to("center") → "ctr"
+* Usage in parsing    (XML → Options):  xsdAlign.from("ctr")  → "center"
 */
-const parseUniversalMeasure = (measure) => {
-	const match = measure.match(/^(-?[0-9]+(?:\.[0-9]+)?)(mm|cm|in|pt|pc|pi|px)$/);
-	if (!match) throw new Error(`Invalid universal measure: '${measure}'`);
-	const [, value, unit] = match;
-	if (value === void 0 || unit === void 0) throw new Error(`Invalid universal measure: '${measure}'`);
+/** Invert a Record<K, V> into Record<V, K>. */
+function invertMap(map) {
+	const result = {};
+	for (const key of Object.keys(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 {
-		value: parseFloat(value),
-		unit
-	};
-};
-/**
-* Converts a UniversalMeasure string to TWIP (twentieths of a point).
-*
-* Supports units: mm, cm, in, pt, pc (picas, 1pc = 12pt), pi (alias for pc).
-*
-* @param measure - A universal measure string like "2.54cm", "1in", "12pt"
-* @returns The value in TWIP
-*
-* @example
-* ```typescript
-* convertUniversalMeasureToTwip("1in");    // 1440
-* convertUniversalMeasureToTwip("2.54cm"); // ~1440 (1 inch)
-* convertUniversalMeasureToTwip("72pt");   // 1440 (1 inch = 72pt = 1440 twips)
-* ```
-*/
-const convertUniversalMeasureToTwip = (measure) => {
-	const { value, unit } = parseUniversalMeasure(measure);
-	switch (unit) {
-		case "mm": return convertMillimetersToTwip(value);
-		case "cm": return convertMillimetersToTwip(value * 10);
-		case "in": return convertInchesToTwip(value);
-		case "pt": return Math.floor(value * 20);
-		case "pc":
-		case "pi": return Math.floor(value * 12 * 20);
-		case "px": return Math.round(value * 15);
-	}
-};
-/**
-* Converts a measurement value (number or UniversalMeasure) to TWIP.
-*
-* If the value is already a number, it is returned as-is (assumed to be in twips).
-* If the value is a UniversalMeasure string, it is converted to twips.
-*
-* Useful for accepting both `number` and `UniversalMeasure` inputs where
-* the XSD type is a union (e.g., ST_TwipsMeasure, ST_SignedTwipsMeasure).
-*
-* @param val - A numeric twip value or a universal measure string
-* @returns The value in TWIP
-*
-* @example
-* ```typescript
-* convertToTwip(1440);     // 1440 (already twips)
-* convertToTwip("1in");    // 1440
-* convertToTwip("2.54cm"); // ~1440
-* ```
-*/
-const convertToTwip = (val) => typeof val === "string" ? convertUniversalMeasureToTwip(val) : val;
-/**
-* Converts a UniversalMeasure string to EMU (English Metric Units).
-*
-* Supports units: mm, cm, in, pt, pc (picas, 1pc = 12pt), pi (alias for pc).
-*
-* @param measure - A universal measure string like "2.54cm", "1in", "12pt"
-* @returns The value in EMU
-*
-* @example
-* ```typescript
-* convertUniversalMeasureToEmu("1in");    // 914400
-* convertUniversalMeasureToEmu("2.54cm"); // 914400
-* convertUniversalMeasureToEmu("12pt");   // 152400
-* ```
-*/
-const convertUniversalMeasureToEmu = (measure) => {
-	const { value, unit } = parseUniversalMeasure(measure);
-	switch (unit) {
-		case "mm": return Math.round(value * 36e3);
-		case "cm": return Math.round(value * 36e4);
-		case "in": return convertInchesToEmu(value);
-		case "pt": return convertPointsToEmu(value);
-		case "pc":
-		case "pi": return convertPointsToEmu(value * 12);
-		case "px": return convertPixelsToEmu(value);
-	}
-};
-/**
-* Converts a measurement value (number or UniversalMeasure) to EMU.
-*
-* Numbers are returned as-is (assumed EMU). Strings are parsed as
-* UniversalMeasure via {@link convertUniversalMeasureToEmu} — including the
-* project-only `px` unit (96 DPI). The result is always an EMU number written to
-* XML, so px never appears verbatim in the document.
-*
-* Useful for DrawingML fields where the XSD type is a union (e.g., ST_Coordinate).
-*
-* @param val - A numeric EMU value, or a UniversalMeasure string (incl. `${n}px`)
-* @returns The value in EMU
-*
-* @example
-* ```typescript
-* convertToEmu(914400);    // 914400 (already EMU)
-* convertToEmu("1in");     // 914400
-* convertToEmu("2.54cm");  // 914400
-* convertToEmu("200px");   // 1905000 (200 * 9525)
-* ```
-*/
-const convertToEmu = (val) => typeof val === "string" ? convertUniversalMeasureToEmu(val) : val;
-/**
-* Converts a UniversalMeasure string to points (1pt = 1/72 inch).
-*
-* Supports units: mm, cm, in, pt, pc (picas, 1pc = 12pt), pi (alias for pc),
-* px (96 DPI).
-*/
-const convertUniversalMeasureToPt = (measure) => {
-	const { value, unit } = parseUniversalMeasure(measure);
-	switch (unit) {
-		case "mm": return value / 25.4 * 72;
-		case "cm": return value * 10 / 25.4 * 72;
-		case "in": return value * 72;
-		case "pt": return value;
-		case "pc":
-		case "pi": return value * 12;
-		case "px": return value / 96 * 72;
-	}
-};
-/**
-* Converts a measurement value (number or UniversalMeasure) to points.
-*
-* Numbers are returned as-is (assumed to be in points). Strings are parsed as
-* UniversalMeasure. Useful for SpreadsheetML fields where a number is points.
-*/
-const convertToPt = (val) => typeof val === "string" ? convertUniversalMeasureToPt(val) : val;
-/**
-* Converts a UniversalMeasure string to inches.
-*
-* Supports units: mm, cm, in, pt, pc, pi, px (96 DPI).
-*/
-const convertUniversalMeasureToInch = (measure) => {
-	const { value, unit } = parseUniversalMeasure(measure);
-	switch (unit) {
-		case "mm": return value / 25.4;
-		case "cm": return value * 10 / 25.4;
-		case "in": return value;
-		case "pt": return value / 72;
-		case "pc":
-		case "pi": return value * 12 / 72;
-		case "px": return value / 96;
-	}
-};
-/**
-* Converts a measurement value (number or UniversalMeasure) to inches.
-*
-* Numbers are returned as-is (assumed to be in inches). Useful for SpreadsheetML
-* page-margin fields where a number is inches.
-*/
-const convertToInch = (val) => typeof val === "string" ? convertUniversalMeasureToInch(val) : val;
-//#endregion
-//#region src/util/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 of Object.keys(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
+		/** 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({
@@ -2064,6 +1819,16 @@ const xsdPresetShadow = bidi({
 	shadow19: "shdw19",
 	shadow20: "shdw20"
 });
+const xsdLightRigDirection = bidi({
+	topLeft: "tl",
+	top: "t",
+	topRight: "tr",
+	left: "l",
+	right: "r",
+	bottomLeft: "bl",
+	bottom: "b",
+	bottomRight: "br"
+});
 const xsdMaterialType = bidi({
 	legacyMatte: "legacyMatte",
 	legacyPlastic: "legacyPlastic",
@@ -2156,39 +1921,493 @@ const xsdTextCaps = bidi({
 	all: "all",
 	small: "small"
 });
+const xsdAxisPosition = bidi({
+	bottom: "b",
+	left: "l",
+	right: "r",
+	top: "t"
+});
+const xsdLegendPosition = bidi({
+	bottom: "b",
+	topRight: "tr",
+	left: "l",
+	right: "r",
+	top: "t"
+});
+const xsdDataLabelPosition = bidi({
+	bottom: "b",
+	center: "ctr",
+	insideBase: "inBase",
+	insideEnd: "inEnd",
+	left: "l",
+	outsideEnd: "outEnd",
+	right: "r",
+	top: "t"
+});
+const xsdAxisCrossBetween = bidi({ middleOfCategory: "midCat" });
+const xsdAxisCrosses = bidi({ zero: "autoZero" });
+const xsdComments = bidi({
+	none: "commNone",
+	indicator: "commIndicator",
+	comment: "commIndAndComment"
+});
+const xsdErrorValueType = bidi({
+	custom: "cust",
+	fixedValue: "fixedVal",
+	standardDeviation: "stdDev",
+	standardError: "stdErr"
+});
+const xsdSizeRepresents = bidi({ width: "w" });
+const xsdSplitType = bidi({
+	custom: "cust",
+	position: "pos",
+	value: "val"
+});
+const xsdAxisLabelAlignment = bidi({
+	center: "ctr",
+	left: "l",
+	right: "r"
+});
+const xsdAxisOrientation = bidi({
+	ascending: "minMax",
+	descending: "maxMin"
+});
+const xsdTrendlineType = bidi({
+	exponential: "exp",
+	logarithmic: "log",
+	movingAverage: "movingAvg",
+	polynomial: "poly"
+});
+const xsdTextTabAlignment = bidi({
+	left: "l",
+	center: "ctr",
+	right: "r",
+	decimal: "dec"
+});
+const xsdFontAlignment = bidi({
+	top: "t",
+	center: "ctr",
+	bottom: "b"
+});
+const xsdAnimLevel = bidi({
+	level: "lvl",
+	center: "ctr"
+});
+const xsdHierBranch = bidi({
+	left: "l",
+	right: "r",
+	hanging: "hang",
+	standard: "std",
+	initial: "init"
+});
+const xsdHueDirection = bidi({
+	clockwise: "cw",
+	counterClockwise: "ccw"
+});
+const xsdDiagramDirection = bidi({
+	normal: "norm",
+	reversed: "rev"
+});
+const xsdResizeHandles = bidi({
+	exact: "exact",
+	relative: "rel"
+});
+const xsdOnOffStyle = bidi({ default: "def" });
+const xsdAnimClass = bidi({
+	entrance: "entr",
+	emphasis: "emph",
+	mediaCall: "mediacall"
+});
+const xsdAnimCalcMode = bidi({
+	linear: "lin",
+	formula: "fmla"
+});
+const xsdAnimValueType = bidi({
+	string: "str",
+	number: "num",
+	color: "clr"
+});
+const xsdTextBuild = bidi({
+	paragraph: "p",
+	custom: "cust"
+});
+const xsdDiagramBuild = bidi({
+	clockwise: "cw",
+	clockwiseIn: "cwIn",
+	clockwiseOut: "cwOut",
+	counterclockwise: "ccw",
+	counterclockwiseIn: "ccwIn",
+	counterclockwiseOut: "ccwOut",
+	custom: "cust"
+});
+const xsdChartBuild = bidi({
+	seriesElement: "seriesEl",
+	categoryElement: "categoryEl"
+});
+const xsdAnimationDgmBuild = bidi({
+	levelOne: "lvlOne",
+	levelAtOnce: "lvlAtOnce"
+});
+const xsdIterateType = bidi({
+	element: "el",
+	word: "wd",
+	letter: "lt"
+});
+const xsdSlideLayoutType = bidi({
+	text: "tx",
+	twoColumnText: "twoColTx",
+	object: "obj",
+	sectionHeader: "secHead",
+	table: "tbl",
+	clipArtAndText: "clipArtAndTx",
+	pictureText: "picTx",
+	twoObjects: "twoObj",
+	twoTextAndTwoObjects: "twoTxTwoObj",
+	objectAndText: "objTx",
+	verticalText: "vertTx",
+	verticalTitleAndText: "vertTitleAndTx"
+});
+const xsdTextVerticalType = bidi({
+	horizontal: "horz",
+	vertical: "vert",
+	vertical270: "vert270",
+	wordArtVertical: "wordArtVert",
+	eastAsianVertical: "eaVert",
+	mongolianVertical: "mongolianVert",
+	wordArtVerticalRightToLeft: "wordArtVertRtl"
+});
+const xsdDashStyle = bidi({
+	longDash: "lgDash",
+	systemDot: "sysDot",
+	systemDash: "sysDash"
+});
+const xsdOrient = bidi({
+	horizontal: "horz",
+	vertical: "vert"
+});
+const xsdPlaceholderType = bidi({
+	centerTitle: "ctrTitle",
+	date: "dt",
+	slideNumber: "sldNum",
+	footer: "ftr",
+	header: "hdr",
+	object: "obj",
+	table: "tbl",
+	diagram: "dgm",
+	slideImage: "sldImg",
+	picture: "pic"
+});
+const xsdMathStyle = bidi({
+	plain: "p",
+	bold: "b",
+	italic: "i",
+	boldItalic: "bi"
+});
+const xsdTableWidthType = bidi({
+	twips: "dxa",
+	percent: "pct"
+});
+const xsdJcAlignment = bidi({ numericTab: "numTab" });
+const xsdConsolidateFunction = bidi({
+	countNumbers: "countNums",
+	standardDeviation: "stdDev",
+	standardDeviationPopulation: "stdDevp",
+	variance: "var",
+	variancePopulation: "varp"
+});
+const xsdShadingPattern = bidi({
+	horizontalStripe: "horzStripe",
+	verticalStripe: "vertStripe",
+	reverseDiagonalStripe: "reverseDiagStripe",
+	diagonalStripe: "diagStripe",
+	horizontalCross: "horzCross",
+	diagonalCross: "diagCross",
+	thinHorizontalStripe: "thinHorzStripe",
+	thinVerticalStripe: "thinVertStripe",
+	thinReverseDiagonalStripe: "thinReverseDiagStripe",
+	thinDiagonalStripe: "thinDiagStripe",
+	thinHorizontalCross: "thinHorzCross",
+	thinDiagonalCross: "thinDiagCross",
+	percent5: "pct5",
+	percent10: "pct10",
+	percent12: "pct12",
+	percent15: "pct15",
+	percent20: "pct20",
+	percent25: "pct25",
+	percent30: "pct30",
+	percent35: "pct35",
+	percent37: "pct37",
+	percent40: "pct40",
+	percent45: "pct45",
+	percent50: "pct50",
+	percent55: "pct55",
+	percent60: "pct60",
+	percent62: "pct62",
+	percent65: "pct65",
+	percent70: "pct70",
+	percent75: "pct75",
+	percent80: "pct80",
+	percent85: "pct85",
+	percent87: "pct87",
+	percent90: "pct90",
+	percent95: "pct95"
+});
+const xsdTotalsRowFunction = bidi({
+	countNumbers: "countNums",
+	standardDeviation: "stdDev",
+	variance: "var"
+});
 //#endregion
-//#region src/util/data-type.ts
+//#region src/util/converters.ts
 /**
-* Binary input normalization.
+* Apply `fn` to `value` unless it is `undefined`; `undefined` passes through.
 *
-* Accepts the full range of binary inputs (Buffer/Uint8Array/ArrayBuffer/
-* DataView/number[]/string/base64 data URL/…) and normalizes to `Uint8Array`.
-* Centralized here so every entry point (packer, patch, descriptor helpers)
-* shares one definition instead of re-declaring per module.
+* Lets an optional field (e.g. `radius?: number | UniversalMeasure`) be threaded
+* through a conversion without a per-call ternary.
+*/
+const mapOptional = (value, fn) => value === void 0 ? void 0 : fn(value);
+/**
+* Convert public percent (100 = 100%) to OOXML ST_Percentage scalar (1/1000).
+* Math.round ensures JSON-first float input produces exact integer output.
+*/
+const emitPercent = (percent) => Math.round(percent * 1e3);
+/**
+* Convert OOXML ST_Percentage scalar (1/1000) to public percent.
+*/
+const parsePercent = (value) => value / 1e3;
+/**
+* Parse an ST_Percentage attribute that may arrive as either a 1/1000th
+* integer ("50000" = 50%) or a percent literal ("50%"); both are XSD-valid.
+* Returns the caller-facing integer percent.
+*/
+const parsePercentAttr = (raw) => {
+	if (raw === void 0) return void 0;
+	const s = typeof raw === "number" ? String(raw) : raw;
+	return s.endsWith("%") ? Number(s.slice(0, -1)) : parsePercent(Number(s));
+};
+/**
+* Convert public degrees to OOXML ST_Angle / ST_FixedAngle scalar (1/60000).
+* Math.round ensures JSON-first float input produces exact integer output.
+*/
+const emitAngle = (degrees) => Math.round(degrees * 6e4);
+/**
+* Convert OOXML ST_Angle / ST_FixedAngle scalar (1/60000) to public degrees.
+*/
+const parseAngle = (value) => value / 6e4;
+/**
+* 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).
 *
-* @module
+* Returns a possibly fractional (sub-pixel) value. The integer rounding that
+* lived here before permanently discarded sub-pixel precision, which made an
+* EMU → pixel → EMU round-trip lossy (e.g. 5521960 EMU → 580 px → 5524500 EMU).
+* Keeping the fraction lets convertPixelsToEmu restore the exact original EMU.
+* Callers needing an integer pixel for display should Math.round the result.
 */
-const DATA_URL_RE = /^data:([\w.+-]+\/[\w.+-]+)?;base64,/;
-/** Test whether a string is a base64 data URL (`data:[mime];base64,...`). */
-function isBase64DataURL(input) {
-	return DATA_URL_RE.test(input);
-}
-/** Normalize any supported binary input to a `Uint8Array`. */
-function toUint8Array(data, options) {
-	if (data instanceof Uint8Array) return data;
-	if (data instanceof ArrayBuffer) return new Uint8Array(data);
-	if (data instanceof DataView) return new Uint8Array(data.buffer, data.byteOffset, data.byteLength);
-	if (typeof data === "string") {
-		const match = data.match(DATA_URL_RE);
-		if (match) return decodeBase64(data.slice(match[0].length));
-		if (options?.encoding === "base64") return decodeBase64(data);
-		return new TextEncoder().encode(data);
+const convertEmuToPixels = (emus) => 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;
+/** Converts EMU to TWIP (1 TWIP = 635 EMU). */
+const convertEmuToTwip = (emus) => Math.round(emus / 635);
+/** Converts TWIP to EMU (1 TWIP = 635 EMU). */
+const convertTwipToEmu = (twips) => twips * 635;
+/** Converts points to TWIP (1 point = 20 TWIP). */
+const convertPointsToTwip = (points) => Math.round(points * 20);
+/** Converts TWIP to points (1 point = 20 TWIP). */
+const convertTwipToPoints = (twips) => twips / 20;
+/**
+* Parse a UniversalMeasure string into its numeric value and unit.
+*
+* @param measure - A universal measure string like "2.54cm", "-10mm", "1in"
+* @returns The parsed value and unit
+* @throws Error if the format is invalid
+*
+* @example
+* ```typescript
+* parseUniversalMeasure("2.54cm"); // { value: 2.54, unit: "cm" }
+* parseUniversalMeasure("-10mm");  // { value: -10, unit: "mm" }
+* ```
+*/
+const parseUniversalMeasure = (measure) => {
+	const match = measure.match(/^(-?[0-9]+(?:\.[0-9]+)?)(mm|cm|in|pt|pc|pi|px)$/);
+	if (!match) throw new Error(`Invalid universal measure: '${measure}'`);
+	const [, value, unit] = match;
+	if (value === void 0 || unit === void 0) throw new Error(`Invalid universal measure: '${measure}'`);
+	return {
+		value: parseFloat(value),
+		unit
+	};
+};
+/**
+* Converts a UniversalMeasure string to TWIP (twentieths of a point).
+*
+* Supports units: mm, cm, in, pt, pc (picas, 1pc = 12pt), pi (alias for pc).
+*
+* @param measure - A universal measure string like "2.54cm", "1in", "12pt"
+* @returns The value in TWIP
+*
+* @example
+* ```typescript
+* convertUniversalMeasureToTwip("1in");    // 1440
+* convertUniversalMeasureToTwip("2.54cm"); // ~1440 (1 inch)
+* convertUniversalMeasureToTwip("72pt");   // 1440 (1 inch = 72pt = 1440 twips)
+* ```
+*/
+const convertUniversalMeasureToTwip = (measure) => {
+	const { value, unit } = parseUniversalMeasure(measure);
+	switch (unit) {
+		case "mm": return convertMillimetersToTwip(value);
+		case "cm": return convertMillimetersToTwip(value * 10);
+		case "in": return convertInchesToTwip(value);
+		case "pt": return Math.floor(value * 20);
+		case "pc":
+		case "pi": return Math.floor(value * 12 * 20);
+		case "px": return Math.round(value * 15);
 	}
-	if (Array.isArray(data)) return new Uint8Array(data);
-	if (data instanceof Blob) throw new TypeError("Blob input requires async processing");
-	if (data instanceof ReadableStream) throw new TypeError("ReadableStream input requires async processing");
-	throw new TypeError(`Unsupported data type: ${typeof data}`);
-}
+};
+/**
+* Converts a measurement value (number or UniversalMeasure) to TWIP.
+*
+* If the value is already a number, it is returned as-is (assumed to be in twips).
+* If the value is a UniversalMeasure string, it is converted to twips.
+*
+* Useful for accepting both `number` and `UniversalMeasure` inputs where
+* the XSD type is a union (e.g., ST_TwipsMeasure, ST_SignedTwipsMeasure).
+*
+* @param val - A numeric twip value or a universal measure string
+* @returns The value in TWIP
+*
+* @example
+* ```typescript
+* convertToTwip(1440);     // 1440 (already twips)
+* convertToTwip("1in");    // 1440
+* convertToTwip("2.54cm"); // ~1440
+* ```
+*/
+const convertToTwip = (val) => typeof val === "string" ? convertUniversalMeasureToTwip(val) : val;
+/**
+* Converts a UniversalMeasure string to EMU (English Metric Units).
+*
+* Supports units: mm, cm, in, pt, pc (picas, 1pc = 12pt), pi (alias for pc).
+*
+* @param measure - A universal measure string like "2.54cm", "1in", "12pt"
+* @returns The value in EMU
+*
+* @example
+* ```typescript
+* convertUniversalMeasureToEmu("1in");    // 914400
+* convertUniversalMeasureToEmu("2.54cm"); // 914400
+* convertUniversalMeasureToEmu("12pt");   // 152400
+* ```
+*/
+const convertUniversalMeasureToEmu = (measure) => {
+	const { value, unit } = parseUniversalMeasure(measure);
+	switch (unit) {
+		case "mm": return Math.round(value * 36e3);
+		case "cm": return Math.round(value * 36e4);
+		case "in": return convertInchesToEmu(value);
+		case "pt": return convertPointsToEmu(value);
+		case "pc":
+		case "pi": return convertPointsToEmu(value * 12);
+		case "px": return convertPixelsToEmu(value);
+	}
+};
+/**
+* Converts a measurement value (number or UniversalMeasure) to EMU.
+*
+* Numbers are returned as-is (assumed EMU). Strings are parsed as
+* UniversalMeasure via {@link convertUniversalMeasureToEmu} — including the
+* project-only `px` unit (96 DPI). The result is always an EMU number written to
+* XML, so px never appears verbatim in the document.
+*
+* Useful for DrawingML fields where the XSD type is a union (e.g., ST_Coordinate).
+*
+* @param val - A numeric EMU value, or a UniversalMeasure string (incl. `${n}px`)
+* @returns The value in EMU
+*
+* @example
+* ```typescript
+* convertToEmu(914400);    // 914400 (already EMU)
+* convertToEmu("1in");     // 914400
+* convertToEmu("2.54cm");  // 914400
+* convertToEmu("200px");   // 1905000 (200 * 9525)
+* ```
+*/
+const convertToEmu = (val) => typeof val === "string" ? convertUniversalMeasureToEmu(val) : val;
+/**
+* Converts a UniversalMeasure string to points (1pt = 1/72 inch).
+*
+* Supports units: mm, cm, in, pt, pc (picas, 1pc = 12pt), pi (alias for pc),
+* px (96 DPI).
+*/
+const convertUniversalMeasureToPt = (measure) => {
+	const { value, unit } = parseUniversalMeasure(measure);
+	switch (unit) {
+		case "mm": return value / 25.4 * 72;
+		case "cm": return value * 10 / 25.4 * 72;
+		case "in": return value * 72;
+		case "pt": return value;
+		case "pc":
+		case "pi": return value * 12;
+		case "px": return value / 96 * 72;
+	}
+};
+/**
+* Converts a measurement value (number or UniversalMeasure) to points.
+*
+* Numbers are returned as-is (assumed to be in points). Strings are parsed as
+* UniversalMeasure. Useful for SpreadsheetML fields where a number is points.
+*/
+const convertToPt = (val) => typeof val === "string" ? convertUniversalMeasureToPt(val) : val;
+/**
+* Converts a UniversalMeasure string to inches.
+*
+* Supports units: mm, cm, in, pt, pc, pi, px (96 DPI).
+*/
+const convertUniversalMeasureToInch = (measure) => {
+	const { value, unit } = parseUniversalMeasure(measure);
+	switch (unit) {
+		case "mm": return value / 25.4;
+		case "cm": return value * 10 / 25.4;
+		case "in": return value;
+		case "pt": return value / 72;
+		case "pc":
+		case "pi": return value * 12 / 72;
+		case "px": return value / 96;
+	}
+};
+/**
+* Converts a measurement value (number or UniversalMeasure) to inches.
+*
+* Numbers are returned as-is (assumed to be in inches). Useful for SpreadsheetML
+* page-margin fields where a number is inches.
+*/
+const convertToInch = (val) => typeof val === "string" ? convertUniversalMeasureToInch(val) : val;
 //#endregion
 //#region src/util/generators.ts
 /**
@@ -2208,7 +2427,7 @@ const URL_ALPHABET = "useandom-26T198340PX75pxJACKVERYMINDBUSHWOLF_GQZbfghjklqvw
 * Generates a unique lowercase alphanumeric ID using crypto.getRandomValues.
 */
 const uniqueId = () => {
-	const bytes = new Uint8Array(21);
+	const bytes = /* @__PURE__ */ new Uint8Array(21);
 	crypto.getRandomValues(bytes);
 	let id = "";
 	for (const byte of bytes) id += URL_ALPHABET[byte & 63];
@@ -2218,13 +2437,50 @@ const uniqueId = () => {
 * Generates a SHA-1 hash of the provided data.
 */
 const hashedId = (data) => {
-	return bytesToHex(sha1(data instanceof ArrayBuffer ? new Uint8Array(data) : typeof data === "string" ? new TextEncoder().encode(data) : data));
+	const bytes = data instanceof ArrayBuffer ? new Uint8Array(data) : typeof data === "string" ? new TextEncoder().encode(data) : data;
+	return bytesToHex(sha1(bytes));
 };
 /**
 * Generates a UUID v4-style unique identifier using crypto.randomUUID.
 */
 const uniqueUuid = () => crypto.randomUUID();
 //#endregion
-export { Buffer as $, convertInchesToTwip as A, convertTwipToPoints as B, xsdUnderlineStyle as C, convertEmuToPoints as D, convertEmuToPixels as E, convertToEmu as F, emitAngle as G, convertUniversalMeasureToInch as H, convertToInch as I, parseAngle as J, emitPercent as K, convertToPt as L, convertPixelsToEmu as M, convertPointsToEmu as N, convertEmuToTwip as O, convertPointsToTwip as P, encodeBase64 as Q, convertToTwip as R, xsdTextCaps as S, convertEmuToInches as T, convertUniversalMeasureToPt as U, convertUniversalMeasureToEmu as V, convertUniversalMeasureToTwip as W, parseUniversalMeasure as X, parsePercent as Y, decodeBase64 as Z, xsdPresetShadow as _, stripColorHashPrefix as _t, isBase64DataURL as a, hexBinary as at, xsdTextAlign as b, universalMeasureValue as bt, xsdBlendMode as c, longHexNumber as ct, xsdLineCap as d, percentageValue as dt, ThemeColor as et, xsdLineEndSize as f, pointMeasureValue as ft, xsdPenAlignment as g, signedTwipsMeasureValue as gt, xsdPattern as h, signedHpsMeasureValue as ht, uniqueUuid as i, eighthPointMeasureValue as it, convertMillimetersToTwip as j, convertInchesToEmu as k, xsdCompoundLine as l, measurementOrPercentValue as lt, xsdPathFillMode as m, shortHexNumber as mt, uniqueId as n, dateTimeValue as nt, toUint8Array as o, hexColorValue as ot, xsdMaterialType as p, positiveUniversalMeasureValue as pt, mapOptional as q, uniqueNumericIdCreator as r, decimalNumber as rt, invertMap as s, hpsMeasureValue as st, hashedId as t, ThemeFont as tt, xsdEffectContainer as u, parseOnOff as ut, xsdRectAlignment as v, twipsMeasureValue as vt, xsdVerticalMergeRev as w, xsdTextAnchor as x, unsignedDecimalNumber as xt, xsdStrikeStyle as y, uCharHexNumber as yt, convertTwipToEmu as z };
+//#region src/util/image-type.ts
+/** Map a media path's file extension to an image type token. */
+function imageTypeFromPath(path) {
+	switch (path.split(".").pop()?.toLowerCase() ?? "") {
+		case "jpg":
+		case "jpeg": return "jpg";
+		case "png": return "png";
+		case "gif": return "gif";
+		case "bmp": return "bmp";
+		case "tif":
+		case "tiff": return "tif";
+		case "ico": return "ico";
+		case "emf": return "emf";
+		case "wmf": return "wmf";
+		default: return "png";
+	}
+}
+//#endregion
+//#region src/util/ext-uri.ts
+/**
+* Extension-uri matching for a:ext/p:ext style extension lists.
+*
+* @module
+*/
+/**
+* Match an `@uri` attribute against a known extension uri. Producers write
+* GUID-style uris with or without the enclosing braces and in mixed case —
+* both spellings denote the same extension, so compare brace-stripped and
+* case-insensitively.
+*/
+function extUriMatches(actual, expected) {
+	if (actual === void 0) return false;
+	const norm = (uri) => uri.replace(/^[{]+|[}]+$/g, "").toLowerCase();
+	return norm(actual) === norm(expected);
+}
+//#endregion
+export { xsdDiagramDirection as $, pointMeasureValue as $t, parseAngle as A, xsdTextBuild as At, xsdAxisCrossBetween as B, decodeBase64 as Bt, convertUniversalMeasureToEmu as C, xsdSizeRepresents as Ct, emitAngle as D, xsdTableWidthType as Dt, convertUniversalMeasureToTwip as E, xsdStrikeStyle as Et, xsdAnimCalcMode as F, xsdTrendlineType as Ft, xsdBlendMode as G, eighthPointMeasureValue as Gt, xsdAxisLabelAlignment as H, Buffer as Ht, xsdAnimClass as I, xsdUnderlineStyle as It, xsdCompoundLine as J, hpsMeasureValue as Jt, xsdChartBuild as K, hexBinary as Kt, xsdAnimLevel as L, xsdVerticalMergeRev as Lt, parsePercentAttr as M, xsdTextTabAlignment as Mt, parseUniversalMeasure as N, xsdTextVerticalType as Nt, emitPercent as O, xsdTextAlign as Ot, invertMap as P, xsdTotalsRowFunction as Pt, xsdDiagramBuild as Q, percentageValue as Qt, xsdAnimValueType as R, isBase64DataURL as Rt, convertTwipToPoints as S, xsdShadingPattern as St, convertUniversalMeasureToPt as T, xsdSplitType as Tt, xsdAxisOrientation as U, dateTimeValue as Ut, xsdAxisCrosses as V, encodeBase64 as Vt, xsdAxisPosition as W, decimalNumber as Wt, xsdDashStyle as X, measurementOrPercentValue as Xt, xsdConsolidateFunction as Y, longHexNumber as Yt, xsdDataLabelPosition as Z, parseOnOff as Zt, convertToEmu as _, xsdPenAlignment as _t, uniqueNumericIdCreator as a, twipsMeasureValue as an, xsdIterateType as at, convertToTwip as b, xsdRectAlignment as bt, convertEmuToPixels as c, unsignedDecimalNumber as cn, xsdLightRigDirection as ct, convertInchesToEmu as d, xsdMaterialType as dt, positiveUniversalMeasureValue as en, xsdEffectContainer as et, convertInchesToTwip as f, xsdMathStyle as ft, convertPointsToTwip as g, xsdPattern as gt, convertPointsToEmu as h, xsdPathFillMode as ht, uniqueId as i, stripColorHashPrefix as in, xsdHueDirection as it, parsePercent as j, xsdTextCaps as jt, mapOptional as k, xsdTextAnchor as kt, convertEmuToPoints as l, xsdLineCap as lt, convertPixelsToEmu as m, xsdOrient as mt, imageTypeFromPath as n, signedHpsMeasureValue as nn, xsdFontAlignment as nt, uniqueUuid as o, uCharHexNumber as on, xsdJcAlignment as ot, convertMillimetersToTwip as p, xsdOnOffStyle as pt, xsdComments as q, hexColorValue as qt, hashedId as r, signedTwipsMeasureValue as rn, xsdHierBranch as rt, convertEmuToInches as s, universalMeasureValue as sn, xsdLegendPosition as st, extUriMatches as t, shortHexNumber as tn, xsdErrorValueType as tt, convertEmuToTwip as u, xsdLineEndSize as ut, convertToInch as v, xsdPlaceholderType as vt, convertUniversalMeasureToInch as w, xsdSlideLayoutType as wt, convertTwipToEmu as x, xsdResizeHandles as xt, convertToPt as y, xsdPresetShadow as yt, xsdAnimationDgmBuild as z, toUint8Array as zt };
 
-//# sourceMappingURL=generators-CElPsAhd.mjs.map
+//# sourceMappingURL=ext-uri-BHBcIrW7.mjs.map