@office-open/core 0.10.15 → 0.12.0

package/dist/{converters-C_Y2QX1w.mjs → ext-uri-BHBcIrW7.mjs}

@@ -1,5 +1,376 @@
 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;
+	const color = stripColorHashPrefix(val);
+	return hexBinary(color, 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" || s === "t") return true;
+	if (s === "0" || s === "false" || s === "off" || s === "f") 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();
+//#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
@@ -523,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");
@@ -1327,41 +1703,6 @@ function toUint8Array(data, options) {
 	throw new TypeError(`Unsupported data type: ${typeof data}`);
 }
 //#endregion
-//#region src/util/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;
-};
-const URL_ALPHABET = "useandom-26T198340PX75pxJACKVERYMINDBUSHWOLF_GQZbfghjklqvwyzrict";
-/**
-* Generates a unique lowercase alphanumeric ID using crypto.getRandomValues.
-*/
-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();
-};
-/**
-* 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));
-};
-/**
-* Generates a UUID v4-style unique identifier using crypto.randomUUID.
-*/
-const uniqueUuid = () => crypto.randomUUID();
-//#endregion
 //#region src/util/mappings.ts
 /**
 * Bidirectional mappings between user-friendly values and XSD abbreviated values.
@@ -1478,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",
@@ -1570,13 +1921,279 @@ 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/converters.ts
 /**
-* OOXML unit conversion utilities.
+* 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 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).
 */
@@ -1615,6 +2232,14 @@ 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.
 *
@@ -1784,6 +2409,78 @@ const convertUniversalMeasureToInch = (measure) => {
 */
 const convertToInch = (val) => typeof val === "string" ? convertUniversalMeasureToInch(val) : val;
 //#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 };
+//#region src/util/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;
+};
+const URL_ALPHABET = "useandom-26T198340PX75pxJACKVERYMINDBUSHWOLF_GQZbfghjklqvwyzrict";
+/**
+* Generates a unique lowercase alphanumeric ID using crypto.getRandomValues.
+*/
+const uniqueId = () => {
+	const bytes = /* @__PURE__ */ new Uint8Array(21);
+	crypto.getRandomValues(bytes);
+	let id = "";
+	for (const byte of bytes) id += URL_ALPHABET[byte & 63];
+	return id.toLowerCase();
+};
+/**
+* Generates a SHA-1 hash of the provided data.
+*/
+const hashedId = (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
+//#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=converters-C_Y2QX1w.mjs.map
+//# sourceMappingURL=ext-uri-BHBcIrW7.mjs.map