@office-open/core 0.10.15 → 0.11.0

package/dist/{converters-C_Y2QX1w.mjs → generators-CElPsAhd.mjs}

@@ -1,5 +1,418 @@
 import { sha1 } from "@noble/hashes/legacy.js";
 import { bytesToHex } from "@noble/hashes/utils.js";
+//#region src/util/values.ts
+/**
+* Validates and converts a number to an integer (decimal number).
+*
+* Reference: ST_DecimalNumber in OOXML specification
+*
+* @param val - The number to validate and convert
+* @returns The floored integer value
+* @throws Error if the value is NaN
+*
+* @example
+* ```typescript
+* const num = decimalNumber(10.7); // Returns 10
+* const negative = decimalNumber(-5.3); // Returns -5
+* ```
+*/
+const decimalNumber = (val) => {
+	if (!Number.isFinite(val)) throw new Error(`Invalid value '${val}' specified. Must be a finite number.`);
+	return Math.floor(val);
+};
+/**
+* Validates and converts a number to a positive integer (unsigned decimal number).
+*
+* Reference: ST_UnsignedDecimalNumber in OOXML specification
+*
+* @param val - The number to validate and convert
+* @returns The floored positive integer value
+* @throws Error if the value is NaN or negative
+*
+* @example
+* ```typescript
+* const num = unsignedDecimalNumber(10.7); // Returns 10
+* const invalid = unsignedDecimalNumber(-5); // Throws Error
+* ```
+*/
+const unsignedDecimalNumber = (val) => {
+	const value = decimalNumber(val);
+	if (value < 0) throw new Error(`Invalid value '${val}' specified. Must be a positive integer.`);
+	return value;
+};
+/**
+* Validates and normalizes a hexadecimal binary value.
+*
+* The xsd:hexBinary type represents binary data as a sequence of binary octets
+* using hexadecimal encoding, where each binary octet is a two-character
+* hexadecimal number. Both lowercase and uppercase letters A-F are permitted.
+*
+* @param val - The hexadecimal string to validate
+* @param length - The expected length in bytes (not characters)
+* @returns The validated hexadecimal string
+* @throws Error if the value is not a valid hex string of the expected length
+*
+* @example
+* ```typescript
+* hexBinary("0FB8", 2); // Valid: 2 bytes = 4 characters
+* hexBinary("ABC", 2); // Invalid: wrong length
+* ```
+*/
+const hexBinary = (val, length) => {
+	const expectedLength = length * 2;
+	if (val.length !== expectedLength || isNaN(Number(`0x${val}`))) throw new Error(`Invalid hex value '${val}'. Expected ${expectedLength} digit hex value`);
+	return val;
+};
+/**
+* Validates a long hexadecimal number (4 bytes / 8 characters).
+*
+* Reference: ST_LongHexNumber in OOXML specification
+*
+* @param val - The hexadecimal string to validate
+* @returns The validated hexadecimal string
+* @throws Error if the value is not a valid 8-character hex string
+*
+* @example
+* ```typescript
+* const hex = longHexNumber("ABCD1234"); // Valid
+* ```
+*/
+const longHexNumber = (val) => hexBinary(val, 4);
+/**
+* Validates a short hexadecimal number (2 bytes / 4 characters).
+*
+* Reference: ST_ShortHexNumber in OOXML specification
+*
+* @param val - The hexadecimal string to validate
+* @returns The validated hexadecimal string
+* @throws Error if the value is not a valid 4-character hex string
+*
+* @example
+* ```typescript
+* const hex = shortHexNumber("AB12"); // Valid
+* ```
+*/
+const shortHexNumber = (val) => hexBinary(val, 2);
+/**
+* Validates a single-byte hexadecimal number (1 byte / 2 characters).
+*
+* Reference: ST_UcharHexNumber in OOXML specification
+*
+* @param val - The hexadecimal string to validate
+* @returns The validated hexadecimal string
+* @throws Error if the value is not a valid 2-character hex string
+*
+* @example
+* ```typescript
+* const hex = uCharHexNumber("FF"); // Valid
+* ```
+*/
+const uCharHexNumber = (val) => hexBinary(val, 1);
+/**
+* Normalizes a universal measure value by parsing and reformatting.
+*
+* Ensures the numeric portion is properly formatted while preserving the unit.
+*
+* Reference: ST_UniversalMeasure in OOXML specification
+*
+* @param val - The universal measure string to normalize
+* @returns The normalized universal measure
+*
+* @example
+* ```typescript
+* const measure = universalMeasureValue("10.500mm"); // Returns "10.5mm"
+* ```
+*/
+const universalMeasureValue = (val) => {
+	const unit = val.slice(-2);
+	const amount = val.substring(0, val.length - 2);
+	return `${Number(amount)}${unit}`;
+};
+/**
+* Validates and normalizes a positive universal measure value.
+*
+* Reference: ST_PositiveUniversalMeasure in OOXML specification
+*
+* @param val - The positive universal measure string to validate
+* @returns The normalized positive universal measure
+* @throws Error if the value is negative
+*
+* @example
+* ```typescript
+* const measure = positiveUniversalMeasureValue("10.5mm"); // Valid
+* const invalid = positiveUniversalMeasureValue("-5mm"); // Throws Error
+* ```
+*/
+const positiveUniversalMeasureValue = (val) => {
+	const value = universalMeasureValue(val);
+	if (parseFloat(value) < 0) throw new Error(`Invalid value '${value}' specified. Expected a positive number.`);
+	return value;
+};
+/**
+* Validates and normalizes a hexadecimal color value.
+*
+* Accepts either "auto" or a 6-character RGB hex value (with or without # prefix).
+* The # prefix is commonly used but technically invalid in OOXML, so it is stripped
+* for strict compliance.
+*
+* Reference: ST_HexColor in OOXML specification
+*
+* @param val - The color value to validate ("auto" or hex color)
+* @returns The normalized color value
+* @throws Error if the hex color is invalid
+*
+* @example
+* ```typescript
+* const color1 = hexColorValue("auto"); // Returns "auto"
+* const color2 = hexColorValue("FF0000"); // Returns "FF0000"
+* const color3 = hexColorValue("#00FF00"); // Returns "00FF00" (# stripped)
+* ```
+*/
+const hexColorValue = (val) => {
+	if (val === "auto") return val;
+	return hexBinary(stripColorHashPrefix(val), 3);
+};
+/**
+* Strips the leading "#" prefix from a color string if present.
+*
+* Hex color values in OOXML do not include the "#" prefix, but user input
+* commonly includes it. This helper normalizes color strings for OOXML output.
+*
+* @param color - The color string (with or without "#" prefix)
+* @returns The color string without the "#" prefix
+*
+* @example
+* ```typescript
+* stripColorHashPrefix("#FF0000"); // Returns "FF0000"
+* stripColorHashPrefix("00FF00"); // Returns "00FF00"
+* ```
+*/
+const stripColorHashPrefix = (color) => color.charAt(0) === "#" ? color.substring(1) : color;
+/**
+* Parses an ST_OnOff / xsd:boolean attribute value.
+*
+* Accepts the full union lexical space leniently on read: true/false, 1/0
+* (number or string — nativeTypeAttributes coerces 1/0 to numbers), and
+* on/off (legal only in wml's ST_OnOff union, not in xsd:boolean). Emission
+* stays per-schema canonical ("1"/"0").
+*
+* Reference: ST_OnOff in shared-commonSimpleTypes.xsd
+*
+* @param raw - The raw attribute value (string, number, or boolean)
+* @returns The parsed boolean, or undefined when unrecognized
+*
+* @example
+* ```typescript
+* parseOnOff("1"); // true
+* parseOnOff("off"); // false
+* parseOnOff(1); // true (nativeTypeAttributes number coercion)
+* ```
+*/
+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;
+};
+/**
+* Validates a signed TWIP measurement value.
+*
+* Accepts either a universal measure string or a numeric TWIP value.
+*
+* Reference: ST_SignedTwipsMeasure in OOXML specification
+*
+* @param val - The measurement value (universal measure or number)
+* @returns The normalized measurement value
+*
+* @example
+* ```typescript
+* const measure1 = signedTwipsMeasureValue("10mm");
+* const measure2 = signedTwipsMeasureValue(1440); // 1 inch in TWIP
+* ```
+*/
+const signedTwipsMeasureValue = (val) => typeof val === "string" ? universalMeasureValue(val) : decimalNumber(val);
+/**
+* Validates a half-point (HPS) measurement value.
+*
+* Accepts either a positive universal measure string or a positive number.
+* HPS (half-points) are commonly used for font sizes.
+*
+* Reference: ST_HpsMeasure in OOXML specification
+*
+* @param val - The measurement value (positive universal measure or number)
+* @returns The normalized measurement value
+*
+* @example
+* ```typescript
+* const fontSize1 = hpsMeasureValue("12pt");
+* const fontSize2 = hpsMeasureValue(24); // 12pt in half-points
+* ```
+*/
+const hpsMeasureValue = (val) => typeof val === "string" ? positiveUniversalMeasureValue(val) : unsignedDecimalNumber(val);
+/**
+* Validates a signed half-point (HPS) measurement value.
+*
+* Accepts either a universal measure string or a numeric value.
+*
+* Reference: ST_SignedHpsMeasure in OOXML specification
+*
+* @param val - The measurement value (universal measure or number)
+* @returns The normalized measurement value
+*
+* @example
+* ```typescript
+* const spacing1 = signedHpsMeasureValue("6pt");
+* const spacing2 = signedHpsMeasureValue(-12); // Negative spacing
+* ```
+*/
+const signedHpsMeasureValue = (val) => typeof val === "string" ? universalMeasureValue(val) : decimalNumber(val);
+/**
+* Validates a positive TWIP measurement value.
+*
+* Accepts either a positive universal measure string or a positive number.
+*
+* Reference: ST_TwipsMeasure in OOXML specification
+*
+* @param val - The measurement value (positive universal measure or number)
+* @returns The normalized measurement value
+*
+* @example
+* ```typescript
+* const width1 = twipsMeasureValue("25.4mm");
+* const width2 = twipsMeasureValue(1440); // 1 inch in TWIP
+* ```
+*/
+const twipsMeasureValue = (val) => typeof val === "string" ? positiveUniversalMeasureValue(val) : unsignedDecimalNumber(val);
+/**
+* Normalizes a percentage value by parsing and reformatting.
+*
+* Reference: ST_Percentage in OOXML specification
+*
+* @param val - The percentage string to normalize
+* @returns The normalized percentage
+*
+* @example
+* ```typescript
+* const percent = percentageValue("50.000%"); // Returns "50%"
+* ```
+*/
+const percentageValue = (val) => {
+	const percent = val.substring(0, val.length - 1);
+	return `${Number(percent)}%`;
+};
+/**
+* Validates a measurement value that can be expressed as a number, percentage, or universal measure.
+*
+* Reference: ST_MeasurementOrPercent in OOXML specification
+*
+* @param val - The measurement value (number, percentage, or universal measure)
+* @returns The normalized measurement value
+*
+* @example
+* ```typescript
+* const measure1 = measurementOrPercentValue(100); // Unqualified number
+* const measure2 = measurementOrPercentValue("50%"); // Percentage
+* const measure3 = measurementOrPercentValue("10mm"); // Universal measure
+* ```
+*/
+const measurementOrPercentValue = (val) => {
+	if (typeof val === "number") return decimalNumber(val);
+	if (val.slice(-1) === "%") return percentageValue(val);
+	return universalMeasureValue(val);
+};
+/**
+* Validates an eighth-point measurement value.
+*
+* Eighth-points are used for fine-grained measurements in text formatting.
+*
+* Reference: ST_EighthPointMeasure in OOXML specification
+*
+* @param val - The measurement value in eighth-points
+* @returns The validated positive integer value
+*
+* @example
+* ```typescript
+* const measure = eighthPointMeasureValue(16); // 2 points
+* ```
+*/
+const eighthPointMeasureValue = unsignedDecimalNumber;
+/**
+* Validates a point measurement value.
+*
+* Reference: ST_PointMeasure in OOXML specification
+*
+* @param val - The measurement value in points
+* @returns The validated positive integer value
+*
+* @example
+* ```typescript
+* const fontSize = pointMeasureValue(12); // 12pt
+* ```
+*/
+const pointMeasureValue = unsignedDecimalNumber;
+/**
+* Converts a JavaScript Date object to an ISO 8601 date-time string.
+*
+* The format is CCYY-MM-DDThh:mm:ss.sssZ where T is a literal and Z indicates UTC.
+* This matches the xsd:dateTime format required by OOXML.
+*
+* Reference: ST_DateTime in OOXML specification
+*
+* @param val - The Date object to convert
+* @returns An ISO 8601 formatted date-time string
+*
+* @example
+* ```typescript
+* const now = new Date();
+* const timestamp = dateTimeValue(now); // Returns "2024-01-15T10:30:00.000Z"
+* ```
+*/
+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 : {};
 //#endregion
@@ -1294,83 +1707,256 @@ function encodeBase64(bytes) {
 	return btoa(binary);
 }
 //#endregion
-//#region src/util/data-type.ts
+//#region src/util/converters.ts
 /**
-* Binary input normalization.
-*
-* 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.
+* Apply `fn` to `value` unless it is `undefined`; `undefined` passes through.
 *
-* @module
+* Lets an optional field (e.g. `radius?: number | UniversalMeasure`) be threaded
+* through a conversion without a per-call ternary.
 */
-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/generators.ts
+const mapOptional = (value, fn) => value === void 0 ? void 0 : fn(value);
 /**
-* Unique ID generation utilities.
-*
-* @module
+* 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);
 /**
-* Creates a unique numeric ID generator with sequential numbering.
+* Convert OOXML ST_Percentage scalar (1/1000) to public percent.
 */
-const uniqueNumericIdCreator = (initial = 0) => {
-	let currentCount = initial;
-	return () => ++currentCount;
-};
-const URL_ALPHABET = "useandom-26T198340PX75pxJACKVERYMINDBUSHWOLF_GQZbfghjklqvwyzrict";
+const parsePercent = (value) => value / 1e3;
 /**
-* Generates a unique lowercase alphanumeric ID using crypto.getRandomValues.
+* Convert public degrees to OOXML ST_Angle / ST_FixedAngle scalar (1/60000).
+* Math.round ensures JSON-first float input produces exact integer output.
 */
-const uniqueId = () => {
-	const bytes = new Uint8Array(21);
-	crypto.getRandomValues(bytes);
-	let id = "";
-	for (const byte of bytes) id += URL_ALPHABET[byte & 63];
-	return id.toLowerCase();
-};
+const emitAngle = (degrees) => Math.round(degrees * 6e4);
 /**
-* Generates a SHA-1 hash of the provided data.
+* Convert OOXML ST_Angle / ST_FixedAngle scalar (1/60000) to public degrees.
 */
-const hashedId = (data) => {
-	return bytesToHex(sha1(data instanceof ArrayBuffer ? new Uint8Array(data) : typeof data === "string" ? new TextEncoder().encode(data) : data));
-};
+const parseAngle = (value) => value / 6e4;
 /**
-* Generates a UUID v4-style unique identifier using crypto.randomUUID.
+* Converts millimeters to TWIP (twentieths of a point).
 */
-const uniqueUuid = () => crypto.randomUUID();
-//#endregion
-//#region src/util/mappings.ts
+const convertMillimetersToTwip = (millimeters) => Math.floor(millimeters / 25.4 * 72 * 20);
 /**
-* 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"
+* 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).
+*
+* 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.
+*/
+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);
+	}
+};
+/**
+* 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) {
@@ -1571,219 +2157,74 @@ const xsdTextCaps = bidi({
 	small: "small"
 });
 //#endregion
-//#region src/util/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).
-*
-* 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.
-*/
-const convertEmuToPoints = (emus) => emus / 12700;
-/**
-* 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
-	};
-};
+//#region src/util/data-type.ts
 /**
-* Converts a UniversalMeasure string to TWIP (twentieths of a point).
-*
-* Supports units: mm, cm, in, pt, pc (picas, 1pc = 12pt), pi (alias for pc).
+* Binary input normalization.
 *
-* @param measure - A universal measure string like "2.54cm", "1in", "12pt"
-* @returns The value in TWIP
+* 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.
 *
-* @example
-* ```typescript
-* convertUniversalMeasureToTwip("1in");    // 1440
-* convertUniversalMeasureToTwip("2.54cm"); // ~1440 (1 inch)
-* convertUniversalMeasureToTwip("72pt");   // 1440 (1 inch = 72pt = 1440 twips)
-* ```
+* @module
 */
-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);
+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/generators.ts
 /**
-* 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
+* Unique ID generation utilities.
 *
-* @example
-* ```typescript
-* convertToTwip(1440);     // 1440 (already twips)
-* convertToTwip("1in");    // 1440
-* convertToTwip("2.54cm"); // ~1440
-* ```
+* @module
 */
-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
-* ```
+* Creates a unique numeric ID generator with sequential numbering.
 */
-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);
-	}
+const uniqueNumericIdCreator = (initial = 0) => {
+	let currentCount = initial;
+	return () => ++currentCount;
 };
+const URL_ALPHABET = "useandom-26T198340PX75pxJACKVERYMINDBUSHWOLF_GQZbfghjklqvwyzrict";
 /**
-* 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).
+* Generates a unique lowercase alphanumeric ID using crypto.getRandomValues.
 */
-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;
-	}
+const uniqueId = () => {
+	const bytes = new Uint8Array(21);
+	crypto.getRandomValues(bytes);
+	let id = "";
+	for (const byte of bytes) id += URL_ALPHABET[byte & 63];
+	return id.toLowerCase();
 };
 /**
-* 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).
+* Generates a SHA-1 hash of the provided data.
 */
-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;
-	}
+const hashedId = (data) => {
+	return bytesToHex(sha1(data instanceof ArrayBuffer ? new Uint8Array(data) : typeof data === "string" ? new TextEncoder().encode(data) : data));
 };
 /**
-* 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.
+* Generates a UUID v4-style unique identifier using crypto.randomUUID.
 */
-const convertToInch = (val) => typeof val === "string" ? convertUniversalMeasureToInch(val) : val;
+const uniqueUuid = () => crypto.randomUUID();
 //#endregion
-export { xsdStrikeStyle as A, isBase64DataURL as B, xsdLineEndSize as C, xsdPenAlignment as D, xsdPattern as E, xsdVerticalMergeRev as F, decodeBase64 as H, hashedId as I, uniqueId as L, xsdTextAnchor as M, xsdTextCaps as N, xsdPresetShadow as O, xsdUnderlineStyle as P, uniqueNumericIdCreator as R, xsdLineCap as S, xsdPathFillMode as T, encodeBase64 as U, toUint8Array as V, Buffer as W, parseUniversalMeasure as _, convertInchesToTwip as a, xsdCompoundLine as b, convertPointsToEmu as c, convertToPt as d, convertToTwip as f, convertUniversalMeasureToTwip as g, convertUniversalMeasureToPt as h, convertInchesToEmu as i, xsdTextAlign as j, xsdRectAlignment as k, convertToEmu as l, convertUniversalMeasureToInch as m, convertEmuToPixels as n, convertMillimetersToTwip as o, convertUniversalMeasureToEmu as p, convertEmuToPoints as r, convertPixelsToEmu as s, convertEmuToInches as t, convertToInch as u, invertMap as v, xsdMaterialType as w, xsdEffectContainer as x, xsdBlendMode as y, uniqueUuid as z };
+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 };
 
-//# sourceMappingURL=converters-C_Y2QX1w.mjs.map
+//# sourceMappingURL=generators-CElPsAhd.mjs.map