superdoc 1.13.0-next.12 → 1.13.0-next.14

package/dist/chunks/{helpers-DTjYh3Fu.cjs → DocxZipper-Bs5-dXNA.cjs}

@@ -1,4 +1,7 @@
-const require_xml_js = require("./xml-js-XW5hGFSq.cjs");
+const require_rolldown_runtime = require("./rolldown-runtime-Dp2H1eGw.cjs");
+const require_jszip = require("./jszip-DCT9QYaK.cjs");
+const require_xml_js = require("./xml-js--DznO7Gk.cjs");
+const require_helpers = require("./helpers-Cs_Zz44i.cjs");
 var buffer = {};
 var base64Js = {};
 base64Js.byteLength = byteLength;
@@ -1394,10 +1397,10 @@ ieee754.write = function(buffer$1, value, offset, isLE, mLen, nBytes) {
 	}
 })(buffer);
 var Buffer = buffer.Buffer;
-var Blob$1 = buffer.Blob;
+var Blob = buffer.Blob;
 var BlobOptions = buffer.BlobOptions;
 var Buffer$1 = buffer.Buffer;
-var File = buffer.File;
+var File$1 = buffer.File;
 var FileOptions = buffer.FileOptions;
 var INSPECT_MAX_BYTES = buffer.INSPECT_MAX_BYTES;
 var SlowBuffer = buffer.SlowBuffer;
@@ -1411,508 +1414,262 @@ var kMaxLength = buffer.kMaxLength;
 var kStringMaxLength = buffer.kStringMaxLength;
 var resolveObjectURL = buffer.resolveObjectURL;
 var transcode = buffer.transcode;
-var import_lib = require_xml_js.require_lib();
-var PIXELS_PER_INCH = 96;
-function inchesToTwips(inches) {
-	if (inches == null) return;
-	if (typeof inches === "string") inches = parseFloat(inches);
-	return Math.round(Number(inches) * 1440);
+const isXmlLike = (name) => /\.xml$|\.rels$/i.test(name);
+function sniffEncoding(u8) {
+	if (u8.length >= 2) {
+		const b0 = u8[0], b1 = u8[1];
+		if (b0 === 255 && b1 === 254) return "utf-16le";
+		if (b0 === 254 && b1 === 255) return "utf-16be";
+	}
+	let nul = 0;
+	for (let i$1 = 0; i$1 < Math.min(64, u8.length); i$1++) if (u8[i$1] === 0) nul++;
+	if (nul > 16) return "utf-16le";
+	return "utf-8";
 }
-function twipsToInches(twips) {
-	if (twips == null) return;
-	const value = Number(twips);
-	if (Number.isNaN(value)) return;
-	return value / 1440;
+function stripBOM(str) {
+	return str && str.charCodeAt(0) === 65279 ? str.slice(1) : str;
 }
-function twipsToPixels(twips) {
-	if (twips == null) return;
-	return inchesToPixels(twipsToInches(twips));
+function ensureXmlString(content) {
+	if (typeof content === "string") return stripBOM(content);
+	let u8 = null;
+	if (content && typeof content === "object") {
+		if (content instanceof Uint8Array) u8 = content;
+		else if (typeof Buffer !== "undefined" && Buffer.isBuffer && Buffer.isBuffer(content)) u8 = new Uint8Array(content.buffer, content.byteOffset, content.byteLength);
+		else if (ArrayBuffer.isView && ArrayBuffer.isView(content)) u8 = new Uint8Array(content.buffer, content.byteOffset, content.byteLength);
+		else if (content.constructor && (content instanceof ArrayBuffer || content.constructor.name === "ArrayBuffer")) u8 = new Uint8Array(content);
+	}
+	if (!u8) throw new Error("Unsupported content type for XML");
+	const enc = sniffEncoding(u8);
+	return stripBOM(new TextDecoder(enc).decode(u8));
 }
-function pixelsToTwips(pixels) {
-	return inchesToTwips(pixelsToInches(pixels));
-}
-function inchesToPixels(inches) {
-	if (inches == null) return;
-	const pixels = inches * 96;
-	return Math.round(pixels * 1e3) / 1e3;
-}
-function pixelsToInches(pixels) {
-	if (pixels == null) return;
-	return Number(pixels) / 96;
-}
-function twipsToLines(twips) {
-	if (twips == null) return;
-	return twips / 240;
-}
-function linesToTwips(lines) {
-	if (lines == null) return;
-	return lines * 240;
-}
-function halfPointToPoints(halfPoints) {
-	if (halfPoints == null) return;
-	return Math.round(halfPoints) / 2;
-}
-function emuToPixels(emu) {
-	if (emu == null) return;
-	if (typeof emu === "string") emu = parseFloat(emu);
-	const pixels = emu * 96 / 914400;
-	return Math.round(pixels);
-}
-function pixelsToEmu(px) {
-	if (px == null) return;
-	if (typeof px === "string") px = parseFloat(px);
-	return Math.round(px * 9525);
-}
-function eighthPointsToPixels(eighthPoints) {
-	if (eighthPoints == null) return;
-	return parseFloat(eighthPoints) / 8 * 1.3333;
-}
-function pointsToTwips(points) {
-	if (points == null) return;
-	return points * 20;
-}
-function pixelsToEightPoints(pixels) {
-	if (pixels == null) return;
-	return Math.round(pixels * 6);
-}
-function twipsToPt(twips) {
-	if (twips == null) return;
-	return twips / 20;
-}
-function ptToTwips(pt) {
-	if (pt == null) return;
-	return pt * 20;
-}
-function rotToDegrees(rot) {
-	if (rot == null) return;
-	return rot / 6e4;
-}
-function degreesToRot(degrees) {
-	if (degrees == null) return;
-	return degrees * 6e4;
-}
-function pixelsToPolygonUnits(pixels) {
-	if (pixels == null) return;
-	const pu = pixels * 96;
-	return Math.round(pu);
-}
-function polygonUnitsToPixels(pu) {
-	if (pu == null) return;
-	const pixels = Number(pu) / 96;
-	return Math.round(pixels * 1e3) / 1e3;
-}
-function polygonToObj(polygonNode) {
-	if (!polygonNode) return null;
-	const points = [];
-	polygonNode.elements.forEach((element) => {
-		if (["wp:start", "wp:lineTo"].includes(element.name)) {
-			const { x, y } = element.attributes;
-			points.push([polygonUnitsToPixels(x), polygonUnitsToPixels(y)]);
-		}
-	});
-	if (points.length > 1) {
-		const firstPoint = points[0];
-		const lastPoint = points[points.length - 1];
-		if (firstPoint[0] === lastPoint[0] && firstPoint[1] === lastPoint[1]) points.pop();
-	}
-	return points;
-}
-function objToPolygon(points) {
-	if (!points || !Array.isArray(points)) return null;
-	const polygonNode = {
-		name: "wp:wrapPolygon",
-		type: "wp:wrapPolygon",
-		attributes: { edited: "0" },
-		elements: []
-	};
-	points.forEach((point, index) => {
-		const [x, y] = point;
-		const tagName = index === 0 ? "wp:start" : "wp:lineTo";
-		const pointNode = {
-			name: tagName,
-			type: tagName,
-			attributes: {
-				x: pixelsToPolygonUnits(x),
-				y: pixelsToPolygonUnits(y)
+var import_lib = /* @__PURE__ */ require_rolldown_runtime.__toESM(require_xml_js.require_lib(), 1);
+var import_jszip_min = /* @__PURE__ */ require_rolldown_runtime.__toESM(require_jszip.require_jszip_min(), 1);
+var DocxZipper = class {
+	constructor(params = {}) {
+		this.debug = params.debug || false;
+		this.zip = new import_jszip_min.default();
+		this.files = [];
+		this.media = {};
+		this.mediaFiles = {};
+		this.fonts = {};
+	}
+	async getDocxData(file, isNode = false) {
+		const extractedFiles = await this.unzip(file);
+		const files = Object.entries(extractedFiles.files);
+		for (const [, zipEntry] of files) {
+			const name = zipEntry.name;
+			if (isXmlLike(name)) {
+				const content = ensureXmlString(await zipEntry.async("uint8array"));
+				this.files.push({
+					name,
+					content
+				});
+			} else if (name.startsWith("word/media") && name !== "word/media/" || zipEntry.name.startsWith("media") && zipEntry.name !== "media/" || name.startsWith("media") && name !== "media/" || name.startsWith("word/embeddings") && name !== "word/embeddings/") if (isNode) {
+				const fileBase64 = (await zipEntry.async("nodebuffer")).toString("base64");
+				this.mediaFiles[name] = fileBase64;
+			} else {
+				const fileBase64 = await zipEntry.async("base64");
+				const extension = this.getFileExtension(name)?.toLowerCase();
+				if (new Set([
+					"png",
+					"jpg",
+					"jpeg",
+					"gif",
+					"bmp",
+					"tiff",
+					"emf",
+					"wmf",
+					"svg",
+					"webp"
+				]).has(extension)) {
+					this.mediaFiles[name] = `data:image/${extension};base64,${fileBase64}`;
+					const blob = await zipEntry.async("blob");
+					const fileObj = new File([blob], name, { type: blob.type });
+					const imageUrl = URL.createObjectURL(fileObj);
+					this.media[name] = imageUrl;
+				} else this.mediaFiles[name] = fileBase64;
 			}
-		};
-		polygonNode.elements.push(pointNode);
-	});
-	if (points.length > 0) {
-		const [startX, startY] = points[0];
-		const closePointNode = {
-			name: "wp:lineTo",
-			type: "wp:lineTo",
-			attributes: {
-				x: pixelsToPolygonUnits(startX),
-				y: pixelsToPolygonUnits(startY)
+			else if (name.startsWith("word/fonts") && name !== "word/fonts/") {
+				const uint8array = await zipEntry.async("uint8array");
+				this.fonts[name] = uint8array;
 			}
+		}
+		return this.files;
+	}
+	getFileExtension(fileName) {
+		const fileSplit = fileName.split(".");
+		if (fileSplit.length < 2) return null;
+		return fileSplit[fileSplit.length - 1];
+	}
+	async updateContentTypes(docx, media, fromJson, updatedDocs = {}) {
+		const additionalPartNames = Object.keys(updatedDocs || {});
+		const imageExts = new Set([
+			"png",
+			"jpg",
+			"jpeg",
+			"gif",
+			"bmp",
+			"tiff",
+			"emf",
+			"wmf",
+			"svg",
+			"webp"
+		]);
+		const newMediaTypes = Object.keys(media).map((name) => this.getFileExtension(name)).filter((ext) => ext && imageExts.has(ext));
+		const contentTypesPath = "[Content_Types].xml";
+		let contentTypesXml;
+		if (fromJson) if (Array.isArray(docx.files)) contentTypesXml = docx.files.find((file) => file.name === contentTypesPath)?.content || "";
+		else contentTypesXml = docx.files?.[contentTypesPath] || "";
+		else contentTypesXml = await docx.file(contentTypesPath).async("string");
+		let typesString = "";
+		const defaultMediaTypes = require_helpers.getContentTypesFromXml(contentTypesXml);
+		const seenTypes = /* @__PURE__ */ new Set();
+		for (let type of newMediaTypes) {
+			if (defaultMediaTypes.includes(type)) continue;
+			if (seenTypes.has(type)) continue;
+			const newContentType = `<Default Extension="${type}" ContentType="image/${type}"/>`;
+			typesString += newContentType;
+			seenTypes.add(type);
+		}
+		const types = JSON.parse(import_lib.xml2json(contentTypesXml, null, 2)).elements?.find((el) => el.name === "Types") || {};
+		const hasComments = types.elements?.some((el) => el.name === "Override" && el.attributes.PartName === "/word/comments.xml");
+		const hasCommentsExtended = types.elements?.some((el) => el.name === "Override" && el.attributes.PartName === "/word/commentsExtended.xml");
+		const hasCommentsIds = types.elements?.some((el) => el.name === "Override" && el.attributes.PartName === "/word/commentsIds.xml");
+		const hasCommentsExtensible = types.elements?.some((el) => el.name === "Override" && el.attributes.PartName === "/word/commentsExtensible.xml");
+		const hasFile = (filename) => {
+			if (updatedDocs && Object.prototype.hasOwnProperty.call(updatedDocs, filename)) return true;
+			if (!docx?.files) return false;
+			if (!fromJson) return Boolean(docx.files[filename]);
+			if (Array.isArray(docx.files)) return docx.files.some((file) => file.name === filename);
+			return Boolean(docx.files[filename]);
 		};
-		polygonNode.elements.push(closePointNode);
-	}
-	return polygonNode;
-}
-var REMOTE_RESOURCE_PATTERN = /^https?:|^blob:|^file:/i;
-var DATA_URI_PATTERN = /^data:/i;
-var getArrayBufferFromUrl = async (input) => {
-	if (input == null) return /* @__PURE__ */ new ArrayBuffer(0);
-	if (input instanceof ArrayBuffer) return input;
-	if (ArrayBuffer.isView(input)) {
-		const view = input;
-		return view.buffer.slice(view.byteOffset, view.byteOffset + view.byteLength);
-	}
-	if (typeof Blob !== "undefined" && input instanceof Blob) return await input.arrayBuffer();
-	if (typeof input !== "string") throw new TypeError("Unsupported media input type");
-	const trimmed = input.trim();
-	const shouldFetchRemote = REMOTE_RESOURCE_PATTERN.test(trimmed);
-	const isDataUri = DATA_URI_PATTERN.test(trimmed);
-	if (shouldFetchRemote) {
-		if (typeof fetch !== "function") throw new Error(`Fetch API is not available to retrieve media: ${trimmed}`);
-		const response = await fetch(trimmed);
-		if (!response.ok) throw new Error(`Fetch failed: ${response.status} ${response.statusText}`);
-		return await response.arrayBuffer();
-	}
-	const base64Payload = isDataUri ? trimmed.split(",", 2)[1] : trimmed.replace(/\s/g, "");
-	try {
-		if (typeof globalThis.atob === "function") {
-			const binary = globalThis.atob(base64Payload);
-			const bytes = new Uint8Array(binary.length);
-			for (let i$1 = 0; i$1 < binary.length; i$1++) bytes[i$1] = binary.charCodeAt(i$1);
-			return bytes.buffer;
+		if (hasFile("word/comments.xml")) {
+			const commentsDef = `<Override PartName="/word/comments.xml" ContentType="application/vnd.openxmlformats-officedocument.wordprocessingml.comments+xml" />`;
+			if (!hasComments) typesString += commentsDef;
 		}
-	} catch (err) {
-		console.warn("atob failed, falling back to Buffer:", err);
-	}
-	const buf = Buffer.from(base64Payload, "base64");
-	return buf.buffer.slice(buf.byteOffset, buf.byteOffset + buf.byteLength);
-};
-var getContentTypesFromXml = (contentTypesXml) => {
-	try {
-		return ((0, import_lib.xml2js)(contentTypesXml, { compact: false })?.elements?.[0]?.elements || []).filter((el) => el?.name === "Default").map((el) => el.attributes?.Extension).filter(Boolean);
-	} catch (err) {
-		console.warn("[super-editor] Failed to parse [Content_Types].xml", err);
-		return [];
-	}
-};
-var resolveOpcTargetPath = (target, baseDir = "word") => {
-	if (!target) return null;
-	if (target.includes("://")) return null;
-	if (target.startsWith("/")) return target.slice(1);
-	const segments = `${baseDir}/${target}`.split("/");
-	const resolved = [];
-	for (const seg of segments) if (seg === "..") resolved.pop();
-	else if (seg !== "." && seg !== "") resolved.push(seg);
-	return resolved.join("/");
-};
-var DOCX_HIGHLIGHT_KEYWORD_MAP = new Map([
-	["yellow", "FFFF00"],
-	["green", "00FF00"],
-	["blue", "0000FF"],
-	["cyan", "00FFFF"],
-	["magenta", "FF00FF"],
-	["red", "FF0000"],
-	["darkYellow", "808000"],
-	["darkGreen", "008000"],
-	["darkBlue", "000080"],
-	["darkCyan", "008080"],
-	["darkMagenta", "800080"],
-	["darkGray", "808080"],
-	["darkRed", "800000"],
-	["lightGray", "C0C0C0"],
-	["black", "000000"],
-	["white", "FFFFFF"]
-]);
-var normalizeHexColor = (hex) => {
-	if (!hex) return null;
-	let value = hex.replace("#", "").trim();
-	if (!value) return null;
-	value = value.toUpperCase();
-	if (value.length === 3) value = value.split("").map((c) => c + c).join("");
-	if (value.length === 8) value = value.slice(0, 6);
-	return value;
-};
-var getHexColorFromDocxSystem = (docxColor) => {
-	const hex = DOCX_HIGHLIGHT_KEYWORD_MAP.get(docxColor);
-	return hex ? `#${hex}` : null;
-};
-var getDocxHighlightKeywordFromHex = (hexColor) => {
-	if (!hexColor) return null;
-	if (DOCX_HIGHLIGHT_KEYWORD_MAP.has(hexColor)) return hexColor;
-	const normalized = normalizeHexColor(hexColor);
-	if (!normalized) return null;
-	for (const [keyword, hex] of DOCX_HIGHLIGHT_KEYWORD_MAP.entries()) if (hex === normalized) return keyword;
-	return null;
-};
-function isValidHexColor(color) {
-	if (!color || typeof color !== "string") return false;
-	switch (color.length) {
-		case 3: return /^[0-9A-F]{3}$/i.test(color);
-		case 6: return /^[0-9A-F]{6}$/i.test(color);
-		case 8: return /^[0-9A-F]{8}$/i.test(color);
-		default: return false;
+		if (hasFile("word/commentsExtended.xml")) {
+			const commentsExtendedDef = `<Override PartName="/word/commentsExtended.xml" ContentType="application/vnd.openxmlformats-officedocument.wordprocessingml.commentsExtended+xml" />`;
+			if (!hasCommentsExtended) typesString += commentsExtendedDef;
+		}
+		if (hasFile("word/commentsIds.xml")) {
+			const commentsIdsDef = `<Override PartName="/word/commentsIds.xml" ContentType="application/vnd.openxmlformats-officedocument.wordprocessingml.commentsIds+xml" />`;
+			if (!hasCommentsIds) typesString += commentsIdsDef;
+		}
+		if (hasFile("word/commentsExtensible.xml")) {
+			const commentsExtendedDef = `<Override PartName="/word/commentsExtensible.xml" ContentType="application/vnd.openxmlformats-officedocument.wordprocessingml.commentsExtensible+xml" />`;
+			if (!hasCommentsExtensible) typesString += commentsExtendedDef;
+		}
+		const hasFootnotes = types.elements?.some((el) => el.name === "Override" && el.attributes.PartName === "/word/footnotes.xml");
+		if (hasFile("word/footnotes.xml")) {
+			const footnotesDef = `<Override PartName="/word/footnotes.xml" ContentType="application/vnd.openxmlformats-officedocument.wordprocessingml.footnotes+xml" />`;
+			if (!hasFootnotes) typesString += footnotesDef;
+		}
+		const partNames = new Set(additionalPartNames);
+		if (docx?.files) if (fromJson && Array.isArray(docx.files)) docx.files.forEach((file) => partNames.add(file.name));
+		else Object.keys(docx.files).forEach((key) => partNames.add(key));
+		partNames.forEach((name) => {
+			if (name.includes(".rels")) return;
+			if (!name.includes("header") && !name.includes("footer")) return;
+			const hasExtensible = types.elements?.some((el) => el.name === "Override" && el.attributes.PartName === `/${name}`);
+			const extendedDef = `<Override PartName="/${name}" ContentType="application/vnd.openxmlformats-officedocument.wordprocessingml.${name.includes("header") ? "header" : "footer"}+xml"/>`;
+			if (!hasExtensible) typesString += extendedDef;
+		});
+		const beginningString = "<Types xmlns=\"http://schemas.openxmlformats.org/package/2006/content-types\">";
+		let updatedContentTypesXml = contentTypesXml.replace(beginningString, `${beginningString}${typesString}`);
+		let relationshipsXml = updatedDocs["word/_rels/document.xml.rels"];
+		if (!relationshipsXml) if (fromJson) if (Array.isArray(docx.files)) relationshipsXml = docx.files.find((file) => file.name === "word/_rels/document.xml.rels")?.content;
+		else relationshipsXml = docx.files?.["word/_rels/document.xml.rels"];
+		else relationshipsXml = await docx.file("word/_rels/document.xml.rels")?.async("string");
+		if (relationshipsXml) try {
+			(import_lib.xml2js(relationshipsXml, { compact: false }).elements?.find((el) => el.name === "Relationships"))?.elements?.forEach((rel) => {
+				const type = rel.attributes?.Type;
+				const target = rel.attributes?.Target;
+				if (!type || !target) return;
+				const isHeader = type.includes("/header");
+				const isFooter = type.includes("/footer");
+				if (!isHeader && !isFooter) return;
+				let sanitizedTarget = target.replace(/^\.\//, "");
+				if (sanitizedTarget.startsWith("../")) sanitizedTarget = sanitizedTarget.slice(3);
+				if (sanitizedTarget.startsWith("/")) sanitizedTarget = sanitizedTarget.slice(1);
+				const partName = sanitizedTarget.startsWith("word/") ? sanitizedTarget : `word/${sanitizedTarget}`;
+				partNames.add(partName);
+			});
+		} catch (error) {
+			console.warn("Failed to parse document relationships while updating content types", error);
+		}
+		partNames.forEach((name) => {
+			if (name.includes(".rels")) return;
+			if (!name.includes("header") && !name.includes("footer")) return;
+			if (updatedContentTypesXml.includes(`PartName="/${name}"`)) return;
+			const extendedDef = `<Override PartName="/${name}" ContentType="application/vnd.openxmlformats-officedocument.wordprocessingml.${name.includes("header") ? "header" : "footer"}+xml"/>`;
+			updatedContentTypesXml = updatedContentTypesXml.replace("</Types>", `${extendedDef}</Types>`);
+		});
+		if (fromJson) return updatedContentTypesXml;
+		docx.file(contentTypesPath, updatedContentTypesXml);
+	}
+	async unzip(file) {
+		return await this.zip.loadAsync(file);
+	}
+	async updateZip({ docx, updatedDocs, originalDocxFile, media, fonts, isHeadless, compression = "DEFLATE" }) {
+		let zip;
+		if (originalDocxFile) zip = await this.exportFromOriginalFile(originalDocxFile, updatedDocs, media);
+		else zip = await this.exportFromCollaborativeDocx(docx, updatedDocs, media, fonts);
+		const exportType = isHeadless ? "nodebuffer" : "blob";
+		return await zip.generateAsync({
+			type: exportType,
+			compression,
+			compressionOptions: compression === "DEFLATE" ? { level: 6 } : void 0
+		});
+	}
+	async exportFromCollaborativeDocx(docx, updatedDocs, media, fonts) {
+		const zip = new import_jszip_min.default();
+		for (const file of docx) {
+			const content = file.content;
+			zip.file(file.name, content);
+		}
+		Object.keys(updatedDocs).forEach((key) => {
+			const content = updatedDocs[key];
+			zip.file(key, content);
+		});
+		Object.keys(media).forEach((path) => {
+			const value = media[path];
+			const binaryData = typeof value === "string" ? require_helpers.base64ToUint8Array(value) : value;
+			zip.file(path, binaryData);
+		});
+		for (const [fontName, fontUintArray] of Object.entries(fonts)) zip.file(fontName, fontUintArray);
+		await this.updateContentTypes(zip, media, false, updatedDocs);
+		return zip;
+	}
+	async exportFromOriginalFile(originalDocxFile, updatedDocs, media) {
+		const unzippedOriginalDocx = await this.unzip(originalDocxFile);
+		const filePromises = [];
+		unzippedOriginalDocx.forEach((relativePath, zipEntry) => {
+			const promise = zipEntry.async("string").then((content) => {
+				unzippedOriginalDocx.file(zipEntry.name, content);
+			});
+			filePromises.push(promise);
+		});
+		await Promise.all(filePromises);
+		Object.keys(updatedDocs).forEach((key) => {
+			unzippedOriginalDocx.file(key, updatedDocs[key]);
+		});
+		Object.keys(media).forEach((path) => {
+			unzippedOriginalDocx.file(path, media[path]);
+		});
+		await this.updateContentTypes(unzippedOriginalDocx, media, false, updatedDocs);
+		return unzippedOriginalDocx;
 	}
-}
-var componentToHex = (val) => {
-	const a = Number(val).toString(16);
-	return a.length === 1 ? "0" + a : a;
-};
-var rgbToHex = (rgb) => {
-	return "#" + rgb.match(/\d+/g).map(componentToHex).join("");
-};
-var DEFAULT_SHADING_FOREGROUND_COLOR = "#000000";
-var hexToRgb = (hex) => {
-	const normalized = normalizeHexColor(hex);
-	if (!normalized) return null;
-	return {
-		r: Number.parseInt(normalized.slice(0, 2), 16),
-		g: Number.parseInt(normalized.slice(2, 4), 16),
-		b: Number.parseInt(normalized.slice(4, 6), 16)
-	};
-};
-var clamp01 = (value) => {
-	if (!Number.isFinite(value)) return 0;
-	return Math.min(1, Math.max(0, value));
 };
-var blendHexColors = (backgroundHex, foregroundHex, foregroundRatio) => {
-	const background = hexToRgb(backgroundHex);
-	const foreground = hexToRgb(foregroundHex);
-	if (!background || !foreground) return null;
-	const ratio = clamp01(foregroundRatio);
-	const r = Math.round(background.r * (1 - ratio) + foreground.r * ratio);
-	const g = Math.round(background.g * (1 - ratio) + foreground.g * ratio);
-	const b = Math.round(background.b * (1 - ratio) + foreground.b * ratio);
-	const toByte = (n) => n.toString(16).padStart(2, "0").toUpperCase();
-	return `${toByte(r)}${toByte(g)}${toByte(b)}`;
-};
-var resolveShadingFillColor = (shading) => {
-	if (!shading || typeof shading !== "object") return null;
-	const fill = normalizeHexColor(shading.fill);
-	if (!fill) return null;
-	const pctMatch = (typeof shading.val === "string" ? shading.val.trim().toLowerCase() : "").match(/^pct(\d{1,3})$/);
-	if (!pctMatch) return fill;
-	const pct = Number.parseInt(pctMatch[1], 10);
-	if (!Number.isFinite(pct) || pct < 0 || pct > 100) return fill;
-	return blendHexColors(fill, normalizeHexColor(shading.color) ?? DEFAULT_SHADING_FOREGROUND_COLOR, pct / 100) ?? fill;
-};
-var deobfuscateFont = (arrayBuffer, guidHex) => {
-	const dta = new Uint8Array(arrayBuffer);
-	const guidStr = guidHex.replace(/[-{}]/g, "");
-	if (guidStr.length !== 32) {
-		console.error("Invalid GUID");
-		return;
-	}
-	const guidBytes = new Uint8Array(16);
-	for (let i$1 = 0, j = 0; i$1 < 32; i$1 += 2, j++) {
-		const hexByte = guidStr[i$1] + guidStr[i$1 + 1];
-		guidBytes[j] = parseInt(hexByte, 16);
-	}
-	for (let i$1 = 0; i$1 < 32; i$1++) {
-		const gi = 15 - i$1 % 16;
-		dta[i$1] ^= guidBytes[gi];
-	}
-	return dta.buffer;
-};
-function convertSizeToCSS(value, type) {
-	if (typeof value === "string" && value.endsWith("%")) type = "pct";
-	if (value === null || value === void 0) value = 0;
-	switch (type) {
-		case "dxa":
-		case null:
-		case void 0: return `${twipsToPixels(value)}px`;
-		case "nil": return "0";
-		case "auto": return null;
-		case "pct":
-			let percent;
-			if (typeof value === "number") percent = value * .02;
-			else if (value.endsWith("%")) percent = parseFloat(value.slice(0, -1));
-			else percent = parseFloat(value) * .02;
-			return `${percent}%`;
-		default: return null;
-	}
-}
+var DocxZipper_default = DocxZipper;
 Object.defineProperty(exports, "Buffer", {
 	enumerable: true,
 	get: function() {
 		return Buffer;
 	}
 });
-Object.defineProperty(exports, "convertSizeToCSS", {
-	enumerable: true,
-	get: function() {
-		return convertSizeToCSS;
-	}
-});
-Object.defineProperty(exports, "degreesToRot", {
-	enumerable: true,
-	get: function() {
-		return degreesToRot;
-	}
-});
-Object.defineProperty(exports, "deobfuscateFont", {
-	enumerable: true,
-	get: function() {
-		return deobfuscateFont;
-	}
-});
-Object.defineProperty(exports, "eighthPointsToPixels", {
-	enumerable: true,
-	get: function() {
-		return eighthPointsToPixels;
-	}
-});
-Object.defineProperty(exports, "emuToPixels", {
-	enumerable: true,
-	get: function() {
-		return emuToPixels;
-	}
-});
-Object.defineProperty(exports, "getArrayBufferFromUrl", {
-	enumerable: true,
-	get: function() {
-		return getArrayBufferFromUrl;
-	}
-});
-Object.defineProperty(exports, "getContentTypesFromXml", {
-	enumerable: true,
-	get: function() {
-		return getContentTypesFromXml;
-	}
-});
-Object.defineProperty(exports, "getDocxHighlightKeywordFromHex", {
-	enumerable: true,
-	get: function() {
-		return getDocxHighlightKeywordFromHex;
-	}
-});
-Object.defineProperty(exports, "getHexColorFromDocxSystem", {
-	enumerable: true,
-	get: function() {
-		return getHexColorFromDocxSystem;
-	}
-});
-Object.defineProperty(exports, "halfPointToPoints", {
-	enumerable: true,
-	get: function() {
-		return halfPointToPoints;
-	}
-});
-Object.defineProperty(exports, "inchesToPixels", {
-	enumerable: true,
-	get: function() {
-		return inchesToPixels;
-	}
-});
-Object.defineProperty(exports, "inchesToTwips", {
-	enumerable: true,
-	get: function() {
-		return inchesToTwips;
-	}
-});
-Object.defineProperty(exports, "isValidHexColor", {
-	enumerable: true,
-	get: function() {
-		return isValidHexColor;
-	}
-});
-Object.defineProperty(exports, "linesToTwips", {
-	enumerable: true,
-	get: function() {
-		return linesToTwips;
-	}
-});
-Object.defineProperty(exports, "normalizeHexColor", {
-	enumerable: true,
-	get: function() {
-		return normalizeHexColor;
-	}
-});
-Object.defineProperty(exports, "objToPolygon", {
-	enumerable: true,
-	get: function() {
-		return objToPolygon;
-	}
-});
-Object.defineProperty(exports, "pixelsToEightPoints", {
-	enumerable: true,
-	get: function() {
-		return pixelsToEightPoints;
-	}
-});
-Object.defineProperty(exports, "pixelsToEmu", {
-	enumerable: true,
-	get: function() {
-		return pixelsToEmu;
-	}
-});
-Object.defineProperty(exports, "pixelsToTwips", {
-	enumerable: true,
-	get: function() {
-		return pixelsToTwips;
-	}
-});
-Object.defineProperty(exports, "pointsToTwips", {
-	enumerable: true,
-	get: function() {
-		return pointsToTwips;
-	}
-});
-Object.defineProperty(exports, "polygonToObj", {
-	enumerable: true,
-	get: function() {
-		return polygonToObj;
-	}
-});
-Object.defineProperty(exports, "ptToTwips", {
-	enumerable: true,
-	get: function() {
-		return ptToTwips;
-	}
-});
-Object.defineProperty(exports, "resolveOpcTargetPath", {
-	enumerable: true,
-	get: function() {
-		return resolveOpcTargetPath;
-	}
-});
-Object.defineProperty(exports, "resolveShadingFillColor", {
-	enumerable: true,
-	get: function() {
-		return resolveShadingFillColor;
-	}
-});
-Object.defineProperty(exports, "rgbToHex", {
-	enumerable: true,
-	get: function() {
-		return rgbToHex;
-	}
-});
-Object.defineProperty(exports, "rotToDegrees", {
-	enumerable: true,
-	get: function() {
-		return rotToDegrees;
-	}
-});
-Object.defineProperty(exports, "twipsToInches", {
-	enumerable: true,
-	get: function() {
-		return twipsToInches;
-	}
-});
-Object.defineProperty(exports, "twipsToLines", {
-	enumerable: true,
-	get: function() {
-		return twipsToLines;
-	}
-});
-Object.defineProperty(exports, "twipsToPixels", {
-	enumerable: true,
-	get: function() {
-		return twipsToPixels;
-	}
-});
-Object.defineProperty(exports, "twipsToPt", {
+Object.defineProperty(exports, "DocxZipper_default", {
 	enumerable: true,
 	get: function() {
-		return twipsToPt;
+		return DocxZipper_default;
 	}
 });