@office-open/core 0.10.12 → 0.10.13

package/dist/util-Tq9PSjK0.mjs

@@ -0,0 +1,1113 @@
+import { U as encodeBase64, W as Buffer } from "./converters-C_Y2QX1w.mjs";
+import { AsyncZipDeflate, Zip, ZipPassThrough, strFromU8, strFromU8 as strFromU8$1, unzipSync as unzipSync$1, zip, zipSync } from "fflate";
+import { sha512 } from "@noble/hashes/sha2.js";
+//#region src/opc/output.ts
+/**
+* Output type definitions for OOXML document export.
+*
+* @module
+*/
+const OoxmlMimeType = {
+	DOCX: "application/vnd.openxmlformats-officedocument.wordprocessingml.document",
+	PPTX: "application/vnd.openxmlformats-officedocument.presentationml.presentation",
+	XLSX: "application/vnd.openxmlformats-officedocument.spreadsheetml.sheet"
+};
+const convertOutput = (data, type, mimeType = OoxmlMimeType.DOCX) => {
+	switch (type) {
+		case "nodebuffer": return Buffer.from(data.buffer, data.byteOffset, data.byteLength);
+		case "blob": return new Blob([data.buffer.slice(data.byteOffset, data.byteOffset + data.byteLength)], { type: mimeType });
+		case "arraybuffer": return data.buffer.slice(data.byteOffset, data.byteOffset + data.byteLength);
+		case "uint8array": return data;
+		case "base64": return encodeBase64(data);
+		case "string":
+		case "text":
+		case "binarystring": return strFromU8(data, true);
+		case "array": return [...data];
+		default: return data;
+	}
+};
+//#endregion
+//#region src/opc/zip-native.ts
+const CRC_TABLE = new Int32Array(256);
+for (let i = 0; i < 256; i++) {
+	let c = i;
+	for (let k = 0; k < 8; k++) c = c & 1 ? c >>> 1 ^ -306674912 : c >>> 1;
+	CRC_TABLE[i] = c;
+}
+function computeCrc32(data) {
+	let crc = -1;
+	for (const byte of data) crc = CRC_TABLE[(crc ^ byte) & 255] ^ crc >>> 8;
+	return ~crc;
+}
+let _nativeDeflate;
+let _nativeDeflateAsync;
+let _nativeInflate;
+let _nativeCrc32;
+try {
+	const zlib = await import("node:zlib");
+	if (typeof zlib.deflateRawSync !== "function") throw new Error("no native deflate");
+	_nativeDeflate = (data, level) => zlib.deflateRawSync(data, { level });
+	_nativeDeflateAsync = (data, level) => new Promise((resolve, reject) => zlib.deflateRaw(data, { level }, (err, result) => {
+		if (err) reject(err);
+		else resolve(result);
+	}));
+	_nativeCrc32 = typeof zlib.crc32 === "function" ? (data) => zlib.crc32(data) : computeCrc32;
+	if (typeof zlib.inflateRawSync === "function") _nativeInflate = (data) => zlib.inflateRawSync(data);
+} catch {}
+const hasNativeDeflate = () => _nativeDeflate !== void 0;
+const hasNativeInflate = () => _nativeInflate !== void 0;
+function wU16(b, o, v) {
+	b[o] = v & 255;
+	b[o + 1] = v >> 8 & 255;
+}
+function wU32(b, o, v) {
+	b[o] = v & 255;
+	b[o + 1] = v >> 8 & 255;
+	b[o + 2] = v >> 16 & 255;
+	b[o + 3] = v >> 24 & 255;
+}
+function resolveEntryData(raw, defaultLevel) {
+	if (Array.isArray(raw)) return {
+		data: raw[0],
+		level: raw[1].level ?? defaultLevel
+	};
+	return {
+		data: raw,
+		level: defaultLevel
+	};
+}
+function compressOne(data, level, deflate) {
+	if (level === 0) return {
+		compressed: data,
+		method: 0
+	};
+	const compressed = deflate(data, level);
+	if (compressed.length >= data.length) return {
+		compressed: data,
+		method: 0
+	};
+	return {
+		compressed,
+		method: 8
+	};
+}
+async function compressOneAsync(data, level, deflate) {
+	if (level === 0) return {
+		compressed: data,
+		method: 0
+	};
+	const compressed = await deflate(data, level);
+	if (compressed.length >= data.length) return {
+		compressed: data,
+		method: 0
+	};
+	return {
+		compressed,
+		method: 8
+	};
+}
+function writeZipBuffer(entries) {
+	let totalSize = 0;
+	for (const e of entries) totalSize += 30 + e.filename.length + e.data.length;
+	const cdOffset = totalSize;
+	let cdSize = 0;
+	for (const e of entries) cdSize += 46 + e.filename.length;
+	totalSize += cdSize + 22;
+	const buf = new Uint8Array(totalSize);
+	let offset = 0;
+	for (const e of entries) {
+		e.localOffset = offset;
+		wU32(buf, offset, 67324752);
+		wU16(buf, offset + 4, 20);
+		wU16(buf, offset + 6, 0);
+		wU16(buf, offset + 8, e.method);
+		wU16(buf, offset + 10, 0);
+		wU16(buf, offset + 12, 0);
+		wU32(buf, offset + 14, e.crc);
+		wU32(buf, offset + 18, e.data.length);
+		wU32(buf, offset + 22, e.uncompressedSize);
+		wU16(buf, offset + 26, e.filename.length);
+		wU16(buf, offset + 28, 0);
+		offset += 30;
+		buf.set(e.filename, offset);
+		offset += e.filename.length;
+		buf.set(e.data, offset);
+		offset += e.data.length;
+	}
+	for (const e of entries) {
+		wU32(buf, offset, 33639248);
+		wU16(buf, offset + 4, 20);
+		wU16(buf, offset + 6, 20);
+		wU16(buf, offset + 8, 0);
+		wU16(buf, offset + 10, e.method);
+		wU16(buf, offset + 12, 0);
+		wU16(buf, offset + 14, 0);
+		wU32(buf, offset + 16, e.crc);
+		wU32(buf, offset + 20, e.data.length);
+		wU32(buf, offset + 24, e.uncompressedSize);
+		wU16(buf, offset + 28, e.filename.length);
+		wU16(buf, offset + 30, 0);
+		wU16(buf, offset + 32, 0);
+		wU16(buf, offset + 34, 0);
+		wU16(buf, offset + 36, 0);
+		wU32(buf, offset + 38, 0);
+		wU32(buf, offset + 42, e.localOffset);
+		offset += 46;
+		buf.set(e.filename, offset);
+		offset += e.filename.length;
+	}
+	wU32(buf, offset, 101010256);
+	wU16(buf, offset + 4, 0);
+	wU16(buf, offset + 6, 0);
+	wU16(buf, offset + 8, entries.length);
+	wU16(buf, offset + 10, entries.length);
+	wU32(buf, offset + 12, cdSize);
+	wU32(buf, offset + 16, cdOffset);
+	wU16(buf, offset + 20, 0);
+	return buf;
+}
+const textEncoder = new TextEncoder();
+const textDecoder = new TextDecoder();
+function nativeZip(files, level = 6) {
+	if (!_nativeDeflate) throw new Error("Native deflate not available");
+	const crc = _nativeCrc32 ?? computeCrc32;
+	const entries = [];
+	for (const key of Object.keys(files)) {
+		const raw = files[key];
+		if (raw === void 0) continue;
+		const { data, level: entryLevel } = resolveEntryData(raw, level);
+		const c = crc(data);
+		const { compressed, method } = compressOne(data, entryLevel, _nativeDeflate);
+		entries.push({
+			filename: textEncoder.encode(key),
+			data: compressed,
+			uncompressedSize: data.length,
+			crc: c,
+			method,
+			localOffset: 0
+		});
+	}
+	return writeZipBuffer(entries);
+}
+async function nativeZipAsync(files, level = 6) {
+	if (!_nativeDeflateAsync) throw new Error("Native async deflate not available");
+	const crc = _nativeCrc32 ?? computeCrc32;
+	const entries = [];
+	for (const key of Object.keys(files)) {
+		const raw = files[key];
+		if (raw === void 0) continue;
+		const { data, level: entryLevel } = resolveEntryData(raw, level);
+		const c = crc(data);
+		const { compressed, method } = await compressOneAsync(data, entryLevel, _nativeDeflateAsync);
+		entries.push({
+			filename: textEncoder.encode(key),
+			data: compressed,
+			uncompressedSize: data.length,
+			crc: c,
+			method,
+			localOffset: 0
+		});
+	}
+	return writeZipBuffer(entries);
+}
+function rU16(b, o) {
+	return b[o] | b[o + 1] << 8;
+}
+function rU32(b, o) {
+	return (b[o] | b[o + 1] << 8 | b[o + 2] << 16 | b[o + 3] << 24) >>> 0;
+}
+const EOCD_MAGIC = 101010256;
+const CD_MAGIC = 33639248;
+/** Locate the End-of-Central-Directory record (within a 64 KB comment window). */
+function findEocd(b) {
+	const min = Math.max(0, b.length - 65557);
+	for (let i = b.length - 22; i >= min; i--) if (rU32(b, i) === EOCD_MAGIC) return i;
+	throw new Error("ZIP EOCD record not found");
+}
+/** Walk the central directory and resolve each entry's payload offset. */
+function readCentralDirectory(buf) {
+	const eocd = findEocd(buf);
+	const count = rU16(buf, eocd + 10);
+	const cdOffset = rU32(buf, eocd + 16);
+	const entries = [];
+	let p = cdOffset;
+	for (let i = 0; i < count; i++) {
+		if (rU32(buf, p) !== CD_MAGIC) throw new Error(`ZIP central directory corrupt at offset ${p}`);
+		const method = rU16(buf, p + 10);
+		const crc = rU32(buf, p + 16);
+		const compSize = rU32(buf, p + 20);
+		const nameLen = rU16(buf, p + 28);
+		const extraLen = rU16(buf, p + 30);
+		const cmtLen = rU16(buf, p + 32);
+		const localOff = rU32(buf, p + 42);
+		const name = textDecoder.decode(buf.subarray(p + 46, p + 46 + nameLen));
+		const lNameLen = rU16(buf, localOff + 26);
+		const lExtraLen = rU16(buf, localOff + 28);
+		entries.push({
+			name,
+			method,
+			compSize,
+			crc,
+			dataStart: localOff + 30 + lNameLen + lExtraLen
+		});
+		p += 46 + nameLen + extraLen + cmtLen;
+	}
+	return entries;
+}
+/**
+* Decompress a ZIP archive via `node:zlib` `inflateRawSync`, mirroring fflate's
+* `unzipSync` signature and CRC-32 integrity check. Node/Bun only — callers
+* gate on {@link hasNativeInflate} and fall back to fflate `unzipSync` elsewhere.
+* Measured ~2x faster than fflate on large OOXML packages.
+*/
+function nativeUnzip(buf) {
+	if (!_nativeInflate) throw new Error("Native inflate not available");
+	const inflate = _nativeInflate;
+	const crc = _nativeCrc32 ?? computeCrc32;
+	const out = {};
+	for (const e of readCentralDirectory(buf)) {
+		const raw = buf.subarray(e.dataStart, e.dataStart + e.compSize);
+		const dec = e.method === 0 ? raw.slice() : inflate(raw);
+		if (crc(dec) >>> 0 !== e.crc) throw new Error(`ZIP CRC-32 mismatch: ${e.name}`);
+		out[e.name] = dec;
+	}
+	return out;
+}
+//#endregion
+//#region src/opc/packer.ts
+/**
+* Shared packer utilities for OOXML document generation.
+*
+* @module
+*/
+/** Default DEFLATE level for XML entries (SuperFast, matching MS Office). */
+const ZIP_DEFLATE_LEVEL = 1;
+/** Level for already-compressed media — STORE (no compression). */
+const ZIP_STORED_LEVEL = 0;
+/**
+* Media formats already compressed internally (DEFLATE for PNG, DCT for JPEG,
+* LZW for GIF). Re-compressing via zip DEFLATE wastes CPU and often inflates
+* the data, so MS Office STORE-s these (CompressionOption.NotCompressed → zip
+* method 0). Everything else (EMF/WMF/BMP/TIFF/SVG/…) is compressible → DEFLATE.
+*/
+const PRECOMPRESSED_MEDIA_EXT = new Set([
+	"jpg",
+	"jpeg",
+	"png",
+	"gif"
+]);
+/**
+* Resolve the ZIP level for a media entry by file-name extension, matching MS
+* Office: already-compressed raster formats → STORE (0), everything else →
+* DEFLATE (`mediaLevel`, default Normal). A `compression.media` override
+* therefore applies only to compressible formats, never forcing DEFLATE onto
+* pre-compressed assets.
+*/
+const levelForMediaName = (fileName, mediaLevel) => {
+	const dot = fileName.lastIndexOf(".");
+	const ext = dot < 0 ? "" : fileName.slice(dot + 1).toLowerCase();
+	return PRECOMPRESSED_MEDIA_EXT.has(ext) ? 0 : mediaLevel;
+};
+/**
+* Asynchronously compress files and convert to the requested output format.
+*
+* Uses fflate Web Workers for non-blocking DEFLATE compression.
+* XML entries use DEFLATE level 1 (SuperFast) by default. Media entries are
+* split by type, matching MS Office: already-compressed formats (PNG/JPEG/GIF)
+* are STOREd, everything else uses the `media` level (default Normal).
+* Set `{ media: ZIP_STORED_LEVEL }` to STORE all compressible media too.
+*/
+const zipAndConvert = async (files, type, mimeType, level = 1) => {
+	return convertOutput(hasNativeDeflate() ? await nativeZipAsync(files, level) : await new Promise((resolve, reject) => {
+		zip(files, {
+			level,
+			consume: true
+		}, (err, data) => {
+			if (err) reject(err);
+			else resolve(data);
+		});
+	}), type, mimeType);
+};
+/**
+* Synchronously compress files and convert to the requested output format.
+*
+* Uses synchronous DEFLATE compression for maximum throughput.
+* Blocks the event loop — prefer {@link zipAndConvert} in server contexts.
+*/
+const zipSyncAndConvert = (files, type, mimeType, level = 1) => {
+	return convertOutput(hasNativeDeflate() ? nativeZip(files, level) : zipSync(files, { level }), type, mimeType);
+};
+/**
+* Create a `ReadableStream<Uint8Array>` from compressed file entries.
+*
+* Uses fflate's `AsyncZipDeflate` for non-blocking DEFLATE compression.
+* `STORED` entries (media) pass through synchronously.
+* Works in both Node.js and browsers (Web Streams API).
+*/
+const createZipStream = (files, defaultLevel = 1) => {
+	return new ReadableStream({ start(controller) {
+		try {
+			const zip = new Zip((err, chunk, _final) => {
+				if (err) {
+					controller.error(err);
+					return;
+				}
+				controller.enqueue(chunk);
+				if (_final) controller.close();
+			});
+			for (const [name, data] of Object.entries(files)) {
+				const raw = Array.isArray(data) ? data[0] : data;
+				const level = Array.isArray(data) ? data[1].level ?? defaultLevel : defaultLevel;
+				const entry = level === 0 ? new ZipPassThrough(name) : new AsyncZipDeflate(name, { level });
+				zip.add(entry);
+				entry.push(raw, true);
+			}
+			zip.end();
+		} catch (err) {
+			controller.error(err instanceof Error ? err : new Error(String(err)));
+		}
+	} });
+};
+/**
+* Create a Packer object with all output format methods.
+*
+* Centralises the ZIP → convert pipeline and the streaming implementation
+* so that each OOXML package only needs to provide a `compile` function and
+* a MIME type.
+*/
+const createPacker = (options) => {
+	const { compile, mimeType } = options;
+	const pack = async (file, opts) => {
+		const type = opts?.type ?? "nodebuffer";
+		return zipAndConvert(compile(file, opts?.overrides ?? [], opts?.compression?.media ?? 6), type, mimeType, opts?.compression?.xml ?? 1);
+	};
+	const toBytes = (file, opts) => pack(file, {
+		...opts,
+		type: "uint8array"
+	});
+	const toString = (file, opts) => pack(file, {
+		...opts,
+		type: "string"
+	});
+	const toBuffer = (file, opts) => pack(file, {
+		...opts,
+		type: "nodebuffer"
+	});
+	const toBase64 = (file, opts) => pack(file, {
+		...opts,
+		type: "base64"
+	});
+	const toBlob = (file, opts) => pack(file, {
+		...opts,
+		type: "blob"
+	});
+	const toArrayBuffer = (file, opts) => pack(file, {
+		...opts,
+		type: "arraybuffer"
+	});
+	const packSync = (file, opts) => {
+		const type = opts?.type ?? "nodebuffer";
+		return zipSyncAndConvert(compile(file, opts?.overrides ?? [], opts?.compression?.media ?? 6), type, mimeType, opts?.compression?.xml ?? 1);
+	};
+	const toBytesSync = (file, opts) => packSync(file, {
+		...opts,
+		type: "uint8array"
+	});
+	const toStringSync = (file, opts) => packSync(file, {
+		...opts,
+		type: "string"
+	});
+	const toBufferSync = (file, opts) => packSync(file, {
+		...opts,
+		type: "nodebuffer"
+	});
+	const toBase64Sync = (file, opts) => packSync(file, {
+		...opts,
+		type: "base64"
+	});
+	const toBlobSync = (file, opts) => packSync(file, {
+		...opts,
+		type: "blob"
+	});
+	const toArrayBufferSync = (file, opts) => packSync(file, {
+		...opts,
+		type: "arraybuffer"
+	});
+	const toStream = (file, opts) => {
+		const mediaLevel = opts?.compression?.media ?? 6;
+		let files;
+		try {
+			files = compile(file, opts?.overrides ?? [], mediaLevel);
+		} catch (err) {
+			return new ReadableStream({ start(controller) {
+				controller.error(err instanceof Error ? err : new Error(String(err)));
+			} });
+		}
+		return createZipStream(files, opts?.compression?.xml ?? 1);
+	};
+	return {
+		compile,
+		pack,
+		packSync,
+		toBytes,
+		toBytesSync,
+		toString,
+		toStringSync,
+		toBuffer,
+		toBufferSync,
+		toBase64,
+		toBase64Sync,
+		toBlob,
+		toBlobSync,
+		toArrayBuffer,
+		toArrayBufferSync,
+		toStream
+	};
+};
+//#endregion
+//#region src/util/compile.ts
+/**
+* Shared compiler utilities for OOXML document generation.
+*
+* @module
+*/
+/** Reusable TextEncoder instance (stateless, safe to share). */
+const encoder = new TextEncoder();
+/**
+* Convert a mapping of XML files + overrides + media into a Zippable structure.
+*
+* Centralises the mapping→Zippable conversion shared by all three compilers.
+*/
+function compileMapping(mapping, overrides, media, mediaLevel = 0) {
+	const files = {};
+	for (const entry of Object.values(mapping)) files[entry.path] = encoder.encode(entry.data);
+	if (overrides) for (const o of overrides) files[o.path] = typeof o.data === "string" ? encoder.encode(o.data) : o.data;
+	if (media) for (const m of media) files[m.path] = [m.data, { level: levelForMediaName(m.path, mediaLevel) }];
+	return files;
+}
+//#endregion
+//#region src/util/crypto.ts
+/**
+* Password hashing utilities for OOXML document protection.
+*
+* Implements ECMA-376 Agile Encryption password derivation.
+* Passwords are encoded as UTF-16LE per the OOXML specification.
+*
+* Uses @noble/hashes for SHA-512 — audited, cross-platform,
+* and comparable in speed to node:crypto for this workload.
+*
+* @module
+*/
+function utf16leEncode(str) {
+	const bytes = new Uint8Array(str.length * 2);
+	for (let i = 0; i < str.length; i++) {
+		const code = str.charCodeAt(i);
+		bytes[i * 2] = code & 255;
+		bytes[i * 2 + 1] = code >> 8 & 255;
+	}
+	return bytes;
+}
+function randomBytes(length) {
+	const bytes = new Uint8Array(length);
+	if (typeof crypto !== "undefined" && crypto.getRandomValues) crypto.getRandomValues(bytes);
+	else for (let i = 0; i < length; i++) bytes[i] = Math.floor(Math.random() * 256);
+	return bytes;
+}
+/**
+* Computes the ECMA-376 Agile Encryption hash for a password.
+*
+* Algorithm: SHA-512(salt + UTF-16LE(password)), then iterate
+* SHA-512(hash + i.toUint32LE()) spinCount times.
+*/
+function hashPasswordAgile(password, salt, spinCount) {
+	const pwBytes = utf16leEncode(password);
+	const initial = new Uint8Array(salt.length + pwBytes.length);
+	initial.set(salt, 0);
+	initial.set(pwBytes, salt.length);
+	let h = sha512(initial);
+	for (let i = 0; i < spinCount; i++) {
+		const buf = new Uint8Array(h.length + 4);
+		buf.set(h, 0);
+		buf[h.length] = i & 255;
+		buf[h.length + 1] = i >> 8 & 255;
+		buf[h.length + 2] = i >> 16 & 255;
+		buf[h.length + 3] = i >> 24 & 255;
+		h = sha512(buf);
+	}
+	return encodeBase64(new Uint8Array(h));
+}
+/**
+* Derives a password hash for OOXML document protection.
+*
+* Returns base64-encoded hashValue, saltValue, spinCount, and algorithmName
+* suitable for direct use in document protection options.
+*/
+function derivePasswordHash(password, spinCount = 1e5) {
+	const salt = randomBytes(16);
+	return {
+		hashValue: hashPasswordAgile(password, salt, spinCount),
+		saltValue: encodeBase64(salt),
+		spinCount,
+		algorithmName: "SHA-512"
+	};
+}
+//#endregion
+//#region src/util/placeholder.ts
+const formatId = (offset, index, style) => style === "rId" ? `rId${offset + index}` : `${offset + index}`;
+/** Single-pass regex replacement for `{key}` placeholders using a Map lookup. */
+const PLACEHOLDER_RE = /\{([^{}]+)\}/g;
+function replacePlaceholders(xml, map) {
+	const parts = [];
+	let last = 0;
+	for (const m of xml.matchAll(PLACEHOLDER_RE)) {
+		const key = m[1];
+		if (key === void 0) continue;
+		const replacement = map.get(key);
+		if (replacement !== void 0) {
+			parts.push(xml.substring(last, m.index), replacement);
+			last = m.index + m[0].length;
+		}
+	}
+	if (last === 0) return xml;
+	parts.push(xml.substring(last));
+	return parts.join("");
+}
+function hasPlaceholders(xml) {
+	return xml.includes("{");
+}
+function collectPlaceholderKeys(xml, prefix) {
+	const keys = /* @__PURE__ */ new Set();
+	const search = `{${prefix}`;
+	let pos = 0;
+	while ((pos = xml.indexOf(search, pos)) !== -1) {
+		const keyStart = pos + search.length;
+		const keyEnd = xml.indexOf("}", keyStart);
+		if (keyEnd === -1) break;
+		const key = xml.substring(keyStart, keyEnd);
+		if (key.length > 0) keys.add(key);
+		pos = keyEnd + 1;
+	}
+	return [...keys];
+}
+function replaceImagePlaceholders(xml, mediaData, offset, idFormat = "rId") {
+	if (mediaData.length === 0) return xml;
+	const map = /* @__PURE__ */ new Map();
+	for (const [i, item] of mediaData.entries()) map.set(item.fileName, formatId(offset, i, idFormat));
+	return replacePlaceholders(xml, map);
+}
+function getReferencedMedia(xml, mediaArray) {
+	return mediaArray.filter((image) => xml.includes(`{${image.fileName}}`));
+}
+/**
+* Combined find + replace for image placeholders in a single pass.
+*
+* Scans XML for `{fileName}` placeholders, replaces them with formatted IDs,
+* and returns the list of referenced media items for relationship registration.
+* More efficient than calling getReferencedMedia() + replaceImagePlaceholders() separately.
+*/
+function findAndReplaceImagePlaceholders(xml, mediaArray, offset, idFormat = "rId") {
+	if (mediaArray.length === 0 || !hasPlaceholders(xml)) return {
+		xml,
+		referenced: []
+	};
+	const itemMap = /* @__PURE__ */ new Map();
+	for (const item of mediaArray) itemMap.set(item.fileName, item);
+	const referenced = [];
+	const replaceMap = /* @__PURE__ */ new Map();
+	const parts = [];
+	let last = 0;
+	for (const m of xml.matchAll(PLACEHOLDER_RE)) {
+		const key = m[1];
+		if (key === void 0) continue;
+		const item = itemMap.get(key);
+		if (item !== void 0) {
+			if (!replaceMap.has(key)) {
+				replaceMap.set(key, formatId(offset, referenced.length, idFormat));
+				referenced.push(item);
+			}
+			parts.push(xml.substring(last, m.index), replaceMap.get(key));
+			last = m.index + m[0].length;
+		}
+	}
+	if (last === 0) return {
+		xml,
+		referenced: []
+	};
+	parts.push(xml.substring(last));
+	return {
+		xml: parts.join(""),
+		referenced
+	};
+}
+/**
+* Replace all placeholder types in a single pass.
+*
+* Combines image, chart, smartart, and arbitrary key-value replacements
+* into one regex scan of the XML string. Used by compilers to avoid
+* multiple full-string passes on large documents.
+*/
+function replaceAllPlaceholders(xml, entries) {
+	if (entries.length === 0 || !hasPlaceholders(xml)) return xml;
+	const map = /* @__PURE__ */ new Map();
+	for (const { prefix, key, value } of entries) map.set(prefix ? `${prefix}${key}` : key, value);
+	return replacePlaceholders(xml, map);
+}
+function replaceChartPlaceholders(xml, chartKeys, offset, idFormat = "rId") {
+	if (chartKeys.length === 0) return xml;
+	const map = /* @__PURE__ */ new Map();
+	for (let i = 0; i < chartKeys.length; i++) map.set(`chart:${chartKeys[i]}`, formatId(offset, i, idFormat));
+	return replacePlaceholders(xml, map);
+}
+function replaceSmartArtPlaceholders(xml, keys, dataOffset, idFormat = "rId") {
+	if (keys.length === 0) return xml;
+	const count = keys.length;
+	const loOffset = dataOffset + count;
+	const qsOffset = loOffset + count;
+	const csOffset = qsOffset + count;
+	const map = /* @__PURE__ */ new Map();
+	for (let i = 0; i < count; i++) {
+		map.set(`smartart:${keys[i]}`, formatId(dataOffset, i, idFormat));
+		map.set(`smartart-lo:${keys[i]}`, formatId(loOffset, i, idFormat));
+		map.set(`smartart-qs:${keys[i]}`, formatId(qsOffset, i, idFormat));
+		map.set(`smartart-cs:${keys[i]}`, formatId(csOffset, i, idFormat));
+	}
+	return replacePlaceholders(xml, map);
+}
+function addSmartArtRelationships(keys, addRel, baseOffset, globalStartIndex, options) {
+	const { pathPrefix, styleRelType } = options;
+	const count = keys.length;
+	const loOffset = baseOffset + count;
+	const qsOffset = loOffset + count;
+	const csOffset = qsOffset + count;
+	for (let i = 0; i < keys.length; i++) {
+		const gi = globalStartIndex + i;
+		addRel(baseOffset + i, "http://schemas.openxmlformats.org/officeDocument/2006/relationships/diagramData", `${pathPrefix}diagrams/data${gi + 1}.xml`);
+		addRel(loOffset + i, "http://schemas.openxmlformats.org/officeDocument/2006/relationships/diagramLayout", `${pathPrefix}diagrams/layout${gi + 1}.xml`);
+		addRel(qsOffset + i, styleRelType, `${pathPrefix}diagrams/quickStyle${gi + 1}.xml`);
+		addRel(csOffset + i, "http://schemas.openxmlformats.org/officeDocument/2006/relationships/diagramColors", `${pathPrefix}diagrams/colors${gi + 1}.xml`);
+		addRel(csOffset + count + i, "http://schemas.microsoft.com/office/2007/relationships/diagramDrawing", `${pathPrefix}diagrams/drawing${gi + 1}.xml`);
+	}
+}
+/** Replace `{reference-instance}` placeholders with numId values. */
+function replaceNumberingPlaceholders(xml, concreteNumberings) {
+	if (concreteNumberings.length === 0) return xml;
+	const map = /* @__PURE__ */ new Map();
+	for (const { reference, instance, numId } of concreteNumberings) map.set(`${reference}-${instance}`, numId.toString());
+	return replacePlaceholders(xml, map);
+}
+/** Replace `{media:fileName}` placeholders with relationship IDs. */
+function replaceMediaPlaceholders(xml, mediaData, offset) {
+	if (mediaData.length === 0) return xml;
+	const map = /* @__PURE__ */ new Map();
+	for (const [i, item] of mediaData.entries()) map.set(`media:${item.fileName}`, formatId(offset, i, "rId"));
+	return replacePlaceholders(xml, map);
+}
+/** Replace `{video:fileName}` placeholders with relationship IDs. */
+function replaceVideoPlaceholders(xml, mediaData, offset) {
+	if (mediaData.length === 0) return xml;
+	const map = /* @__PURE__ */ new Map();
+	for (const [i, item] of mediaData.entries()) map.set(`video:${item.fileName}`, formatId(offset, i, "rId"));
+	return replacePlaceholders(xml, map);
+}
+/** Collect media items referenced by `{media:...}` placeholders in XML. */
+function getMediaRefs(xml, mediaArray) {
+	return collectPrefixedRefs(xml, "media:", mediaArray);
+}
+/** Collect media items referenced by `{video:...}` placeholders in XML. */
+function getVideoRefs(xml, mediaArray) {
+	return collectPrefixedRefs(xml, "video:", mediaArray);
+}
+function collectPrefixedRefs(xml, prefix, mediaArray) {
+	const keys = /* @__PURE__ */ new Set();
+	const search = `{${prefix}`;
+	let pos = 0;
+	while ((pos = xml.indexOf(search, pos)) !== -1) {
+		const keyStart = pos + search.length;
+		const keyEnd = xml.indexOf("}", keyStart);
+		if (keyEnd === -1) break;
+		keys.add(xml.substring(keyStart, keyEnd));
+		pos = keyEnd + 1;
+	}
+	return mediaArray.filter((m) => keys.has(m.fileName));
+}
+/** Replace `{hlink:key}` placeholders with relationship IDs. */
+function replaceHyperlinkPlaceholders(xml, hyperlinks, offset) {
+	if (hyperlinks.length === 0) return xml;
+	const map = /* @__PURE__ */ new Map();
+	for (const [i, h] of hyperlinks.entries()) map.set(`hlink:${h.key}`, formatId(offset, i, "rId"));
+	return replacePlaceholders(xml, map);
+}
+//#endregion
+//#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(val.charAt(0) === "#" ? val.substring(1) : val, 3);
+};
+/**
+* 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
+export { convertOutput as $, replaceChartPlaceholders as A, compileMapping as B, findAndReplaceImagePlaceholders as C, getVideoRefs as D, getReferencedMedia as E, replaceSmartArtPlaceholders as F, levelForMediaName as G, ZIP_STORED_LEVEL as H, replaceVideoPlaceholders as I, zipAndConvert as J, strFromU8$1 as K, derivePasswordHash as L, replaceImagePlaceholders as M, replaceMediaPlaceholders as N, hasPlaceholders as O, replaceNumberingPlaceholders as P, OoxmlMimeType as Q, hashPasswordAgile as R, collectPlaceholderKeys as S, getMediaRefs as T, createPacker as U, ZIP_DEFLATE_LEVEL as V, createZipStream as W, hasNativeInflate as X, zipSyncAndConvert as Y, nativeUnzip as Z, twipsMeasureValue as _, eighthPointMeasureValue as a, unsignedDecimalNumber as b, hpsMeasureValue as c, percentageValue as d, pointMeasureValue as f, signedTwipsMeasureValue as g, signedHpsMeasureValue as h, decimalNumber as i, replaceHyperlinkPlaceholders as j, replaceAllPlaceholders as k, longHexNumber as l, shortHexNumber as m, ThemeFont as n, hexBinary as o, positiveUniversalMeasureValue as p, unzipSync$1 as q, dateTimeValue as r, hexColorValue as s, ThemeColor as t, measurementOrPercentValue as u, uCharHexNumber as v, formatId as w, addSmartArtRelationships as x, universalMeasureValue as y, randomBytes as z };
+
+//# sourceMappingURL=util-Tq9PSjK0.mjs.map