superdoc 1.13.0-next.9 → 1.13.0

package/dist/chunks/{helpers-OFep8CYR.cjs → DocxZipper-B6nm2R9-.cjs}

@@ -1,5 +1,6 @@
 "use strict";
-const xmlJs = require("./xml-js-D1navVqh.cjs");
+const helpers = require("./helpers-CCzma9mJ.cjs");
+const jszip_min = require("./jszip.min-oAFpNMh5.cjs");
 var buffer = {};
 var base64Js = {};
 base64Js.byteLength = byteLength;
@@ -1759,409 +1760,316 @@ ieee754.write = function(buffer2, value, offset, isLE, mLen, nBytes) {
   }
 })(buffer);
 const Buffer = buffer.Buffer;
-var libExports = xmlJs.requireLib();
-const 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 = 0; i < Math.min(64, u8.length); i++) if (u8[i] === 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;
-  const inches = twipsToInches(twips);
-  return inchesToPixels(inches);
+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);
+  let xml = new TextDecoder(enc).decode(u8);
+  return stripBOM(xml);
 }
-function pixelsToTwips(pixels) {
-  const inches = pixelsToInches(pixels);
-  return inchesToTwips(inches);
-}
-function inchesToPixels(inches) {
-  if (inches == null) return;
-  const pixels = inches * PIXELS_PER_INCH;
-  return Math.round(pixels * 1e3) / 1e3;
-}
-function pixelsToInches(pixels) {
-  if (pixels == null) return;
-  const inches = Number(pixels) / PIXELS_PER_INCH;
-  return inches;
-}
-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 * PIXELS_PER_INCH / 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;
-  const points = parseFloat(eighthPoints) / 8;
-  const pixels = points * 1.3333;
-  return pixels;
-}
-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 * PIXELS_PER_INCH;
-  return Math.round(pu);
-}
-function polygonUnitsToPixels(pu) {
-  if (pu == null) return;
-  const pixels = Number(pu) / PIXELS_PER_INCH;
-  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();
+class DocxZipper {
+  constructor(params = {}) {
+    this.debug = params.debug || false;
+    this.zip = new jszip_min.JSZip();
+    this.files = [];
+    this.media = {};
+    this.mediaFiles = {};
+    this.fonts = {};
+  }
+  /**
+   * Get all docx data from the zipped docx
+   *
+   * [ContentTypes].xml
+   * _rels/.rels
+   * word/document.xml
+   * word/_rels/document.xml.rels
+   * word/footnotes.xml
+   * word/endnotes.xml
+   * word/header1.xml
+   * word/theme/theme1.xml
+   * word/settings.xml
+   * word/styles.xml
+   * word/webSettings.xml
+   * word/fontTable.xml
+   * docProps/core.xml
+   * docProps/app.xml
+   * */
+  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 u8 = await zipEntry.async("uint8array");
+        const content = ensureXmlString(u8);
+        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 buffer2 = await zipEntry.async("nodebuffer");
+          const fileBase64 = buffer2.toString("base64");
+          this.mediaFiles[name] = fileBase64;
+        } else {
+          const fileBase64 = await zipEntry.async("base64");
+          const extension = this.getFileExtension(name)?.toLowerCase();
+          const imageTypes = /* @__PURE__ */ new Set(["png", "jpg", "jpeg", "gif", "bmp", "tiff", "emf", "wmf", "svg", "webp"]);
+          if (imageTypes.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;
+          }
+        }
+      } else if (name.startsWith("word/fonts") && name !== "word/fonts/") {
+        const uint8array = await zipEntry.async("uint8array");
+        this.fonts[name] = uint8array;
+      }
     }
-  }
-  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)
+    return this.files;
+  }
+  getFileExtension(fileName) {
+    const fileSplit = fileName.split(".");
+    if (fileSplit.length < 2) return null;
+    return fileSplit[fileSplit.length - 1];
+  }
+  /**
+   * Update [Content_Types].xml with extensions of new Image annotations
+   */
+  async updateContentTypes(docx, media, fromJson, updatedDocs = {}) {
+    const additionalPartNames = Object.keys(updatedDocs || {});
+    const imageExts = /* @__PURE__ */ 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] || "";
       }
-    };
-    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 contentTypesXml = await docx.file(contentTypesPath).async("string");
+    let typesString = "";
+    const defaultMediaTypes = 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 xmlJson = JSON.parse(helpers.libExports.xml2json(contentTypesXml, null, 2));
+    const types = xmlJson.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;
-}
-const REMOTE_RESOURCE_PATTERN = /^https?:|^blob:|^file:/i;
-const DATA_URI_PATTERN = /^data:/i;
-const getArrayBufferFromUrl = async (input) => {
-  if (input == null) {
-    return 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 = 0; i < binary.length; i++) {
-        bytes[i] = binary.charCodeAt(i);
-      }
-      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);
-};
-const getContentTypesFromXml = (contentTypesXml) => {
-  try {
-    const result = libExports.xml2js(contentTypesXml, { compact: false });
-    const types = result?.elements?.[0]?.elements || [];
-    return types.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 [];
-  }
-};
-const 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("/");
-};
-const DOCX_HIGHLIGHT_KEYWORD_MAP = /* @__PURE__ */ 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"]
-]);
-const 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;
-};
-const getHexColorFromDocxSystem = (docxColor) => {
-  const hex = DOCX_HIGHLIGHT_KEYWORD_MAP.get(docxColor);
-  return hex ? `#${hex}` : null;
-};
-const 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;
-  }
-}
-const componentToHex = (val) => {
-  const a = Number(val).toString(16);
-  return a.length === 1 ? "0" + a : a;
-};
-const rgbToHex = (rgb) => {
-  return "#" + rgb.match(/\d+/g).map(componentToHex).join("");
-};
-const DEFAULT_SHADING_FOREGROUND_COLOR = "#000000";
-const 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)
-  };
-};
-const clamp01 = (value) => {
-  if (!Number.isFinite(value)) return 0;
-  return Math.min(1, Math.max(0, value));
-};
-const 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)}`;
-};
-const resolveShadingFillColor = (shading) => {
-  if (!shading || typeof shading !== "object") return null;
-  const fill = normalizeHexColor(shading.fill);
-  if (!fill) return null;
-  const val = typeof shading.val === "string" ? shading.val.trim().toLowerCase() : "";
-  const pctMatch = val.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;
-  const foreground = normalizeHexColor(shading.color) ?? DEFAULT_SHADING_FOREGROUND_COLOR;
-  return blendHexColors(fill, foreground, pct / 100) ?? fill;
-};
-const 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 = 0, j = 0; i < 32; i += 2, j++) {
-    const hexByte = guidStr[i] + guidStr[i + 1];
-    guidBytes[j] = parseInt(hexByte, 16);
-  }
-  for (let i = 0; i < 32; i++) {
-    const gi = 15 - i % 16;
-    dta[i] ^= 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 * 0.02;
+    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 {
-        if (value.endsWith("%")) {
-          percent = parseFloat(value.slice(0, -1));
+        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 type = name.includes("header") ? "header" : "footer";
+      const extendedDef = `<Override PartName="/${name}" ContentType="application/vnd.openxmlformats-officedocument.wordprocessingml.${type}+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 {
-          percent = parseFloat(value) * 0.02;
+          relationshipsXml = docx.files?.["word/_rels/document.xml.rels"];
         }
+      } else {
+        relationshipsXml = await docx.file("word/_rels/document.xml.rels")?.async("string");
+      }
+    }
+    if (relationshipsXml) {
+      try {
+        const relJson = helpers.libExports.xml2js(relationshipsXml, { compact: false });
+        const relationships = relJson.elements?.find((el) => el.name === "Relationships");
+        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);
       }
-      return `${percent}%`;
-    default:
-      return null;
+    }
+    partNames.forEach((name) => {
+      if (name.includes(".rels")) return;
+      if (!name.includes("header") && !name.includes("footer")) return;
+      if (updatedContentTypesXml.includes(`PartName="/${name}"`)) return;
+      const type = name.includes("header") ? "header" : "footer";
+      const extendedDef = `<Override PartName="/${name}" ContentType="application/vnd.openxmlformats-officedocument.wordprocessingml.${type}+xml"/>`;
+      updatedContentTypesXml = updatedContentTypesXml.replace("</Types>", `${extendedDef}</Types>`);
+    });
+    if (fromJson) return updatedContentTypesXml;
+    docx.file(contentTypesPath, updatedContentTypesXml);
+  }
+  async unzip(file) {
+    const zip = await this.zip.loadAsync(file);
+    return zip;
+  }
+  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
+    });
+  }
+  /**
+   * Export the Editor content to a docx file, updating changed docs
+   * @param {Object} docx An object containing the unzipped docx files (keys are relative file names)
+   * @param {Object} updatedDocs An object containing the updated docs (keys are relative file names)
+   * @returns {Promise<JSZip>} The unzipped but updated docx file ready for zipping
+   */
+  async exportFromCollaborativeDocx(docx, updatedDocs, media, fonts) {
+    const zip = new jszip_min.JSZip();
+    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" ? 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;
+  }
+  /**
+   * Export the Editor content to a docx file, updating changed docs
+   * Requires the original docx file
+   * @param {File} originalDocxFile The original docx file
+   * @param {Object} updatedDocs An object containing the updated docs (keys are relative file names)
+   * @returns {Promise<JSZip>} The unzipped but updated docx file ready for zipping
+   */
+  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;
   }
 }
 exports.Buffer = Buffer;
-exports.convertSizeToCSS = convertSizeToCSS;
-exports.degreesToRot = degreesToRot;
-exports.deobfuscateFont = deobfuscateFont;
-exports.eighthPointsToPixels = eighthPointsToPixels;
-exports.emuToPixels = emuToPixels;
-exports.getArrayBufferFromUrl = getArrayBufferFromUrl;
-exports.getContentTypesFromXml = getContentTypesFromXml;
-exports.getDocxHighlightKeywordFromHex = getDocxHighlightKeywordFromHex;
-exports.getHexColorFromDocxSystem = getHexColorFromDocxSystem;
-exports.halfPointToPoints = halfPointToPoints;
-exports.inchesToPixels = inchesToPixels;
-exports.inchesToTwips = inchesToTwips;
-exports.isValidHexColor = isValidHexColor;
-exports.libExports = libExports;
-exports.linesToTwips = linesToTwips;
-exports.normalizeHexColor = normalizeHexColor;
-exports.objToPolygon = objToPolygon;
-exports.pixelsToEightPoints = pixelsToEightPoints;
-exports.pixelsToEmu = pixelsToEmu;
-exports.pixelsToTwips = pixelsToTwips;
-exports.pointsToTwips = pointsToTwips;
-exports.polygonToObj = polygonToObj;
-exports.ptToTwips = ptToTwips;
-exports.resolveOpcTargetPath = resolveOpcTargetPath;
-exports.resolveShadingFillColor = resolveShadingFillColor;
-exports.rgbToHex = rgbToHex;
-exports.rotToDegrees = rotToDegrees;
-exports.twipsToInches = twipsToInches;
-exports.twipsToLines = twipsToLines;
-exports.twipsToPixels = twipsToPixels;
-exports.twipsToPt = twipsToPt;
+exports.DocxZipper = DocxZipper;