@superdoc-dev/cli 0.5.0-next.1 → 0.5.0-next.3

package/dist/index.js

@@ -62964,7 +62964,7 @@ var init_remark_gfm_z_sDF4ss_es = __esm(() => {
   emptyOptions2 = {};
 });
 
-// ../../packages/superdoc/dist/chunks/SuperConverter-DPILugtg.es.js
+// ../../packages/superdoc/dist/chunks/SuperConverter-CXcZg9Os.es.js
 function getExtensionConfigField(extension$1, field, context = { name: "" }) {
   const fieldValue = extension$1.config[field];
   if (typeof fieldValue === "function")
@@ -113235,7 +113235,7 @@ var isRegExp = (value) => {
       state.kern = kernNode.attributes["w:val"];
   }
 }, SuperConverter;
-var init_SuperConverter_DPILugtg_es = __esm(() => {
+var init_SuperConverter_CXcZg9Os_es = __esm(() => {
   init_rolldown_runtime_B2q5OVn9_es();
   init_jszip_ChlR43oI_es();
   init_xml_js_40FWvL78_es();
@@ -149810,8 +149810,11 @@ var init_SuperConverter_DPILugtg_es = __esm(() => {
         numberingXml = baseNumbering;
       const currentNumberingXml = numberingXml.elements[0];
       const referencedNumIds = collectReferencedNumIds(this.convertedXml);
-      const { liveAbstracts, liveDefinitions } = filterOrphanedNumberingDefinitions(this.numbering, referencedNumIds);
-      currentNumberingXml.elements = [...liveAbstracts, ...liveDefinitions];
+      if (this.numbering?.definitions && this.numbering?.abstracts) {
+        const { liveAbstracts, liveDefinitions } = filterOrphanedNumberingDefinitions(this.numbering, referencedNumIds);
+        currentNumberingXml.elements = [...liveAbstracts, ...liveDefinitions];
+      } else
+        currentNumberingXml.elements = [];
       this.convertedXml[numberingPath] = numberingXml;
     }
     #prepareCommentsXmlFilesForExport({ defs, exportType, commentsWithParaIds }) {
@@ -150610,7 +150613,7 @@ var init_remark_stringify_D8vxv_XI_es = __esm(() => {
   eol = /\r?\n|\r/g;
 });
 
-// ../../packages/superdoc/dist/chunks/DocxZipper-gWkmvJfR.es.js
+// ../../packages/superdoc/dist/chunks/dist-Cwvmda4Q.es.js
 function getLens2(b64) {
   var len$1 = b64.length;
   if (len$1 % 4 > 0)
@@ -150685,631 +150688,8 @@ function fromByteArray2(uint8) {
   }
   return parts.join("");
 }
-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 stripBOM(str) {
-  return str && str.charCodeAt(0) === 65279 ? str.slice(1) : str;
-}
-function ensureXmlString(content2) {
-  if (typeof content2 === "string")
-    return stripBOM(content2);
-  let u8 = null;
-  if (content2 && typeof content2 === "object") {
-    if (content2 instanceof Uint8Array)
-      u8 = content2;
-    else if (typeof Buffer3 !== "undefined" && Buffer3.isBuffer && Buffer3.isBuffer(content2))
-      u8 = new Uint8Array(content2.buffer, content2.byteOffset, content2.byteLength);
-    else if (ArrayBuffer.isView && ArrayBuffer.isView(content2))
-      u8 = new Uint8Array(content2.buffer, content2.byteOffset, content2.byteLength);
-    else if (content2.constructor && (content2 instanceof ArrayBuffer || content2.constructor.name === "ArrayBuffer"))
-      u8 = new Uint8Array(content2);
-  }
-  if (!u8)
-    throw new Error("Unsupported content type for XML");
-  const enc = sniffEncoding(u8);
-  let xml = new TextDecoder(enc).decode(u8);
-  xml = stripBOM(xml);
-  if (enc !== "utf-8")
-    xml = xml.replace(/(<\?xml\b[^?]*?)\bencoding\s*=\s*["'][^"']*["']/i, '$1encoding="UTF-8"');
-  return xml;
-}
-function readEntry(path2, baseFiles, updatedDocs) {
-  if (updatedDocs && Object.prototype.hasOwnProperty.call(updatedDocs, path2))
-    return updatedDocs[path2];
-  if (!baseFiles)
-    return;
-  if (Array.isArray(baseFiles))
-    return baseFiles.find((f2) => f2.name === path2)?.content;
-  return baseFiles[path2];
-}
-function partExistsInPackage(zipPath, baseFiles, updatedDocs) {
-  return readEntry(zipPath, baseFiles, updatedDocs) != null;
-}
-function parseXml(xmlString) {
-  try {
-    return import_lib$2.xml2js(xmlString, { compact: false });
-  } catch {
-    return null;
-  }
-}
-function serializeXml(jsObject) {
-  return import_lib$2.js2xml(jsObject, { spaces: 0 });
-}
-function findRootElement(parsed, tagName) {
-  return parsed?.elements?.find((el) => {
-    if (!el.name)
-      return false;
-    return (el.name.includes(":") ? el.name.split(":").pop() : el.name) === tagName;
-  });
-}
-function createEmptyRels() {
-  return {
-    declaration: { attributes: {
-      version: "1.0",
-      encoding: "UTF-8",
-      standalone: "yes"
-    } },
-    elements: [{
-      type: "element",
-      name: "Relationships",
-      attributes: { xmlns: RELATIONSHIPS_NS },
-      elements: []
-    }]
-  };
-}
-function findMaxRId$1(relsRoot) {
-  let max4 = 0;
-  for (const el of relsRoot.elements || []) {
-    const id2 = el.attributes?.Id;
-    if (!id2)
-      continue;
-    const match = id2.match(/^rId(\d+)$/);
-    if (match)
-      max4 = Math.max(max4, parseInt(match[1], 10));
-  }
-  return max4;
-}
-function reconcileContentTypes(typesRoot, presentParts) {
-  if (!typesRoot.elements)
-    typesRoot.elements = [];
-  const managedByPartName = /* @__PURE__ */ new Map;
-  for (const entry of MANAGED_PACKAGE_PARTS)
-    managedByPartName.set(`/${entry.zipPath}`, entry);
-  const existingOverrides = /* @__PURE__ */ new Map;
-  for (let i$1 = 0;i$1 < typesRoot.elements.length; i$1++) {
-    const el = typesRoot.elements[i$1];
-    if (el.name !== "Override")
-      continue;
-    const partName = el.attributes?.PartName;
-    if (!partName || !managedByPartName.has(partName))
-      continue;
-    if (!existingOverrides.has(partName))
-      existingOverrides.set(partName, []);
-    existingOverrides.get(partName).push(i$1);
-  }
-  const indicesToRemove = /* @__PURE__ */ new Set;
-  for (const [partName, entry] of managedByPartName) {
-    const isPresent = presentParts.has(entry.zipPath);
-    const indices = existingOverrides.get(partName) || [];
-    if (!isPresent) {
-      for (const idx of indices)
-        indicesToRemove.add(idx);
-      continue;
-    }
-    if (indices.length === 0)
-      typesRoot.elements.push({
-        type: "element",
-        name: "Override",
-        attributes: {
-          PartName: partName,
-          ContentType: entry.contentType
-        }
-      });
-    else {
-      typesRoot.elements[indices[0]].attributes.ContentType = entry.contentType;
-      for (let i$1 = 1;i$1 < indices.length; i$1++)
-        indicesToRemove.add(indices[i$1]);
-    }
-  }
-  if (indicesToRemove.size > 0) {
-    const sorted = [...indicesToRemove].sort((a, b) => b - a);
-    for (const idx of sorted)
-      typesRoot.elements.splice(idx, 1);
-  }
-}
-function reconcileRootRels(relsRoot, presentParts) {
-  if (!relsRoot.elements)
-    relsRoot.elements = [];
-  const managedByType = /* @__PURE__ */ new Map;
-  for (const entry of MANAGED_PACKAGE_PARTS)
-    managedByType.set(entry.relationshipType, entry);
-  const existingRels = /* @__PURE__ */ new Map;
-  for (let i$1 = 0;i$1 < relsRoot.elements.length; i$1++) {
-    const el = relsRoot.elements[i$1];
-    if (el.name !== "Relationship")
-      continue;
-    const type = el.attributes?.Type;
-    if (!type || !managedByType.has(type))
-      continue;
-    if (!existingRels.has(type))
-      existingRels.set(type, []);
-    existingRels.get(type).push({
-      index: i$1,
-      element: el
-    });
-  }
-  const indicesToRemove = /* @__PURE__ */ new Set;
-  let maxRId = findMaxRId$1(relsRoot);
-  for (const [relType, entry] of managedByType) {
-    const isPresent = presentParts.has(entry.zipPath);
-    const existing = existingRels.get(relType) || [];
-    if (!isPresent) {
-      for (const { index: index2 } of existing)
-        indicesToRemove.add(index2);
-      continue;
-    }
-    if (existing.length === 0) {
-      maxRId++;
-      relsRoot.elements.push({
-        type: "element",
-        name: "Relationship",
-        attributes: {
-          Id: `rId${maxRId}`,
-          Type: relType,
-          Target: entry.zipPath
-        }
-      });
-    } else {
-      existing[0].element.attributes.Target = entry.zipPath;
-      for (let i$1 = 1;i$1 < existing.length; i$1++)
-        indicesToRemove.add(existing[i$1].index);
-    }
-  }
-  if (indicesToRemove.size > 0) {
-    const sorted = [...indicesToRemove].sort((a, b) => b - a);
-    for (const idx of sorted)
-      relsRoot.elements.splice(idx, 1);
-  }
-}
-function syncPackageMetadata({ baseFiles, updatedDocs }) {
-  const presentParts = /* @__PURE__ */ new Set;
-  for (const entry of MANAGED_PACKAGE_PARTS)
-    if (partExistsInPackage(entry.zipPath, baseFiles, updatedDocs))
-      presentParts.add(entry.zipPath);
-  const rawContentTypes = readEntry("[Content_Types].xml", baseFiles, updatedDocs);
-  if (rawContentTypes == null)
-    throw new Error("syncPackageMetadata: [Content_Types].xml is missing from the package. Cannot safely reconcile package metadata without an existing content types file.");
-  const contentTypesParsed = parseXml(rawContentTypes);
-  if (!contentTypesParsed)
-    throw new Error("syncPackageMetadata: [Content_Types].xml could not be parsed as valid XML. Cannot safely reconcile package metadata from a malformed content types file.");
-  const typesRoot = findRootElement(contentTypesParsed, "Types");
-  if (!typesRoot)
-    throw new Error("syncPackageMetadata: [Content_Types].xml does not contain a <Types> root element.");
-  reconcileContentTypes(typesRoot, presentParts);
-  const rawRels = readEntry("_rels/.rels", baseFiles, updatedDocs);
-  let relsParsed;
-  if (rawRels == null)
-    relsParsed = createEmptyRels();
-  else {
-    relsParsed = parseXml(rawRels);
-    if (!relsParsed)
-      throw new Error("syncPackageMetadata: _rels/.rels could not be parsed as valid XML. Cannot safely reconcile root relationships from a malformed rels file.");
-  }
-  let relsRoot = findRootElement(relsParsed, "Relationships");
-  if (!relsRoot) {
-    relsParsed = createEmptyRels();
-    relsRoot = relsParsed.elements[0];
-  }
-  reconcileRootRels(relsRoot, presentParts);
-  return {
-    contentTypesXml: serializeXml(contentTypesParsed),
-    relsXml: serializeXml(relsParsed)
-  };
-}
-function findMaxRId(elements) {
-  let max4 = 0;
-  for (const el of elements) {
-    const match = el.attributes?.Id?.match(/^rId(\d+)$/);
-    if (match)
-      max4 = Math.max(max4, Number(match[1]));
-  }
-  return max4;
-}
-function reconcileDocumentRelationships(relsXml, fileExists) {
-  if (!relsXml)
-    return relsXml;
-  let parsed;
-  try {
-    parsed = import_lib$12.xml2js(relsXml, { compact: false });
-  } catch {
-    return relsXml;
-  }
-  const relsTag = parsed?.elements?.find((el) => el.name === "Relationships");
-  if (!relsTag)
-    return relsXml;
-  if (!relsTag.elements)
-    relsTag.elements = [];
-  let changed = false;
-  let maxId = findMaxRId(relsTag.elements);
-  for (const entry of MANAGED_DOCUMENT_PARTS) {
-    if (!fileExists(entry.zipPath))
-      continue;
-    if (relsTag.elements.some((el) => el.attributes?.Type === entry.relationshipType))
-      continue;
-    maxId++;
-    relsTag.elements.push({
-      type: "element",
-      name: "Relationship",
-      attributes: {
-        Id: `rId${maxId}`,
-        Type: entry.relationshipType,
-        Target: entry.relTarget
-      }
-    });
-    changed = true;
-  }
-  if (!changed)
-    return relsXml;
-  return import_lib$12.js2xml(parsed, { spaces: 0 });
-}
-var DOCX = "application/vnd.openxmlformats-officedocument.wordprocessingml.document", buffer2, base64Js2, lookup2, revLookup2, Arr2, code5 = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/", i3, len2, ieee7542, Buffer3, isXmlLike = (name) => /\.xml$|\.rels$/i.test(name), MANAGED_PACKAGE_PARTS, import_lib$2, RELATIONSHIPS_NS = "http://schemas.openxmlformats.org/package/2006/relationships", import_lib$12, MANAGED_DOCUMENT_PARTS, import_lib3, import_jszip_min, IMAGE_EXTS, MIME_TYPE_FOR_EXT, CUSTOM_XML_ITEM_PROPS_CONTENT_TYPE = "application/vnd.openxmlformats-officedocument.customXmlProperties+xml", FONT_CONTENT_TYPES, DocxZipper = class {
-  constructor(params3 = {}) {
-    this.debug = params3.debug || false;
-    this.zip = new import_jszip_min.default;
-    this.files = [];
-    this.media = {};
-    this.mediaFiles = {};
-    this.fonts = {};
-  }
-  async getDocxData(file, isNode3 = 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 content2 = ensureXmlString(await zipEntry.async("uint8array"));
-        this.files.push({
-          name,
-          content: content2
-        });
-      } 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 (isNode3) {
-          const fileBase64 = (await zipEntry.async("nodebuffer")).toString("base64");
-          this.mediaFiles[name] = fileBase64;
-        } else {
-          const fileBase64 = await zipEntry.async("base64");
-          let extension2 = this.getFileExtension(name)?.toLowerCase();
-          let detectedType = null;
-          if (!IMAGE_EXTS.has(extension2) || extension2 === "tmp") {
-            detectedType = detectImageType(fileBase64);
-            if (detectedType)
-              extension2 = detectedType;
-          }
-          if (IMAGE_EXTS.has(extension2)) {
-            const mimeSubtype = MIME_TYPE_FOR_EXT[extension2] || extension2;
-            this.mediaFiles[name] = `data:image/${mimeSubtype};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 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 = {}, fonts = {}) {
-    const additionalPartNames = Object.keys(updatedDocs || {});
-    const newMediaTypes = Object.keys(media).map((name) => this.getFileExtension(name)).filter((ext) => ext && IMAGE_EXTS.has(ext));
-    const extensionlessMediaOverrides = Object.entries(media).filter(([name]) => !this.getFileExtension(name)).map(([name, value]) => ({
-      name,
-      contentType: this.#detectImageContentType(value)
-    })).filter((entry) => entry.contentType);
-    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 = 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/${MIME_TYPE_FOR_EXT[type] || type}"/>`;
-      typesString += newContentType;
-      seenTypes.add(type);
-    }
-    if (fonts) {
-      const fontExts = new Set(Object.keys(fonts).map((name) => this.getFileExtension(name)).filter((ext) => ext && FONT_CONTENT_TYPES[ext]));
-      for (const ext of fontExts) {
-        if (defaultMediaTypes.includes(ext))
-          continue;
-        if (seenTypes.has(ext))
-          continue;
-        typesString += `<Default Extension="${ext}" ContentType="${FONT_CONTENT_TYPES[ext]}"/>`;
-        seenTypes.add(ext);
-      }
-    }
-    const types3 = JSON.parse(import_lib3.xml2json(contentTypesXml, null, 2)).elements?.find((el) => el.name === "Types") || {};
-    const hasPartOverride = (partName) => types3.elements?.some((el) => el.name === "Override" && el.attributes.PartName === partName);
-    for (const { name, contentType } of extensionlessMediaOverrides) {
-      const partName = `/${name}`;
-      if (hasPartOverride(partName))
-        continue;
-      typesString += `<Override PartName="${partName}" ContentType="${contentType}" />`;
-    }
-    const hasComments = types3.elements?.some((el) => el.name === "Override" && el.attributes.PartName === "/word/comments.xml");
-    const hasCommentsExtended = types3.elements?.some((el) => el.name === "Override" && el.attributes.PartName === "/word/commentsExtended.xml");
-    const hasCommentsIds = types3.elements?.some((el) => el.name === "Override" && el.attributes.PartName === "/word/commentsIds.xml");
-    const hasCommentsExtensible = types3.elements?.some((el) => el.name === "Override" && el.attributes.PartName === "/word/commentsExtensible.xml");
-    const hasFile = (filename) => {
-      if (updatedDocs && Object.prototype.hasOwnProperty.call(updatedDocs, filename))
-        return updatedDocs[filename] !== null;
-      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]);
-    };
-    if (hasFile("word/comments.xml")) {
-      const commentsDef = `<Override PartName="/word/comments.xml" ContentType="application/vnd.openxmlformats-officedocument.wordprocessingml.comments+xml" />`;
-      if (!hasComments)
-        typesString += commentsDef;
-    }
-    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 = types3.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;
-    }
-    for (const entry of MANAGED_DOCUMENT_PARTS)
-      if (hasFile(entry.zipPath) && !hasPartOverride(`/${entry.zipPath}`))
-        typesString += `<Override PartName="/${entry.zipPath}" ContentType="${entry.contentType}" />`;
-    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 (!/^customXml\/itemProps\d+\.xml$/i.test(name))
-        return;
-      if (!hasFile(name))
-        return;
-      const partName = `/${name}`;
-      if (hasPartOverride(partName))
-        return;
-      typesString += `<Override PartName="${partName}" ContentType="${CUSTOM_XML_ITEM_PROPS_CONTENT_TYPE}" />`;
-    });
-    partNames.forEach((name) => {
-      if (name.includes(".rels"))
-        return;
-      if (!name.includes("header") && !name.includes("footer"))
-        return;
-      const hasExtensible = types3.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 staleOverridePartNames = COMMENT_FILE_BASENAMES.map((name) => `/word/${name}`).filter((partName) => {
-      return !hasFile(partName.slice(1));
-    });
-    const beginningString = '<Types xmlns="http://schemas.openxmlformats.org/package/2006/content-types">';
-    let updatedContentTypesXml = contentTypesXml.replace(beginningString, `${beginningString}${typesString}`);
-    for (const partName of staleOverridePartNames) {
-      const escapedPartName = partName.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
-      const overrideRegex = new RegExp(`\\s*<Override[^>]*PartName="${escapedPartName}"[^>]*/>`, "g");
-      updatedContentTypesXml = updatedContentTypesXml.replace(overrideRegex, "");
-    }
-    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_lib3.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 (error3) {
-        console.warn("Failed to parse document relationships while updating content types", error3);
-      }
-    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 (relationshipsXml) {
-      const reconciledRels = reconcileDocumentRelationships(relationshipsXml, hasFile);
-      if (reconciledRels !== relationshipsXml)
-        if (fromJson)
-          updatedDocs["word/_rels/document.xml.rels"] = reconciledRels;
-        else
-          docx.file("word/_rels/document.xml.rels", reconciledRels);
-    }
-    if (fromJson)
-      return updatedContentTypesXml;
-    docx.file(contentTypesPath, updatedContentTypesXml);
-  }
-  async#syncPackageMetadataInZip(zip) {
-    const baseForSync = {};
-    zip.forEach((path2) => {
-      baseForSync[path2] = "";
-    });
-    const ctEntry = zip.file("[Content_Types].xml");
-    if (ctEntry)
-      baseForSync["[Content_Types].xml"] = await ctEntry.async("string");
-    const rlEntry = zip.file("_rels/.rels");
-    if (rlEntry)
-      baseForSync["_rels/.rels"] = await rlEntry.async("string");
-    const { contentTypesXml, relsXml } = syncPackageMetadata({
-      baseFiles: baseForSync,
-      updatedDocs: {}
-    });
-    zip.file("[Content_Types].xml", contentTypesXml);
-    zip.file("_rels/.rels", relsXml);
-  }
-  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, fonts);
-    else
-      zip = await this.exportFromCollaborativeDocx(docx, updatedDocs, media, fonts);
-    const exportType = isHeadless ? "nodebuffer" : "blob";
-    return await zip.generateAsync({
-      type: exportType,
-      mimeType: DOCX,
-      compression,
-      compressionOptions: compression === "DEFLATE" ? { level: 6 } : undefined
-    });
-  }
-  async exportFromCollaborativeDocx(docx, updatedDocs, media, fonts) {
-    if (!Array.isArray(docx))
-      throw new Error("Collaborative DOCX export requires base package entries");
-    const zip = new import_jszip_min.default;
-    for (const file of docx) {
-      const content2 = file.content;
-      zip.file(file.name, content2);
-    }
-    Object.keys(updatedDocs).forEach((key) => {
-      if (updatedDocs[key] === null)
-        zip.remove(key);
-      else
-        zip.file(key, updatedDocs[key]);
-    });
-    Object.keys(media).forEach((path2) => {
-      const value = media[path2];
-      const binaryData = typeof value === "string" ? base64ToUint8Array(value) : value;
-      zip.file(path2, binaryData);
-    });
-    for (const [fontName, fontUintArray] of Object.entries(fonts))
-      zip.file(fontName, fontUintArray);
-    await this.updateContentTypes(zip, media, false, updatedDocs, fonts);
-    await this.#syncPackageMetadataInZip(zip);
-    return zip;
-  }
-  async exportFromOriginalFile(originalDocxFile, updatedDocs, media, fonts) {
-    const unzippedOriginalDocx = await this.unzip(originalDocxFile);
-    const filePromises = [];
-    unzippedOriginalDocx.forEach((relativePath, zipEntry) => {
-      const promise = zipEntry.async("uint8array").then((u8) => {
-        unzippedOriginalDocx.file(zipEntry.name, isXmlLike(zipEntry.name) ? ensureXmlString(u8) : u8);
-      });
-      filePromises.push(promise);
-    });
-    await Promise.all(filePromises);
-    Object.keys(updatedDocs).forEach((key) => {
-      if (updatedDocs[key] === null)
-        unzippedOriginalDocx.remove(key);
-      else
-        unzippedOriginalDocx.file(key, updatedDocs[key]);
-    });
-    Object.keys(media).forEach((path2) => {
-      unzippedOriginalDocx.file(path2, media[path2]);
-    });
-    if (fonts)
-      for (const [fontName, fontUintArray] of Object.entries(fonts))
-        unzippedOriginalDocx.file(fontName, fontUintArray);
-    await this.updateContentTypes(unzippedOriginalDocx, media, false, updatedDocs, fonts);
-    await this.#syncPackageMetadataInZip(unzippedOriginalDocx);
-    return unzippedOriginalDocx;
-  }
-  #detectImageContentType(value) {
-    if (value == null)
-      return null;
-    if (typeof value === "string" && value.startsWith("data:image/"))
-      return value.match(/^data:(image\/[a-zA-Z0-9.+-]+);/i)?.[1]?.toLowerCase() || null;
-    let detectedType = null;
-    if (value instanceof ArrayBuffer)
-      detectedType = detectImageType(new Uint8Array(value));
-    else if (ArrayBuffer.isView(value))
-      detectedType = detectImageType(new Uint8Array(value.buffer, value.byteOffset, value.byteLength));
-    else if (typeof value === "string")
-      detectedType = detectImageType(value.startsWith("data:") ? value.split(",", 2)[1] : value);
-    if (!detectedType)
-      return null;
-    return `image/${MIME_TYPE_FOR_EXT[detectedType] || detectedType}`;
-  }
-}, DocxZipper_default;
-var init_DocxZipper_gWkmvJfR_es = __esm(() => {
-  init_rolldown_runtime_B2q5OVn9_es();
-  init_jszip_ChlR43oI_es();
-  init_xml_js_40FWvL78_es();
-  init_constants_Qqwopz80_es();
+var buffer2, base64Js2, lookup2, revLookup2, Arr2, code5 = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/", i3, len2, ieee7542, Buffer3;
+var init_dist_Cwvmda4Q_es = __esm(() => {
   buffer2 = {};
   base64Js2 = {};
   base64Js2.byteLength = byteLength2;
@@ -152924,6 +152304,1370 @@ var init_DocxZipper_gWkmvJfR_es = __esm(() => {
   buffer2.kStringMaxLength;
   buffer2.resolveObjectURL;
   buffer2.transcode;
+});
+
+// ../../packages/superdoc/dist/chunks/detect-container-CstXTt5n.es.js
+function matchesMagic(bytes, magic) {
+  if (bytes.length < magic.length)
+    return false;
+  for (let i4 = 0;i4 < magic.length; i4++)
+    if (bytes[i4] !== magic[i4])
+      return false;
+  return true;
+}
+function detectContainerType(data) {
+  const bytes = data instanceof Uint8Array ? data : new Uint8Array(data);
+  if (matchesMagic(bytes, ZIP_MAGIC))
+    return "zip";
+  if (matchesMagic(bytes, CFB_MAGIC))
+    return "cfb";
+  return "unknown";
+}
+var ZIP_MAGIC, CFB_MAGIC;
+var init_detect_container_CstXTt5n_es = __esm(() => {
+  ZIP_MAGIC = [
+    80,
+    75,
+    3,
+    4
+  ];
+  CFB_MAGIC = [
+    208,
+    207,
+    17,
+    224,
+    161,
+    177,
+    26,
+    225
+  ];
+});
+
+// ../../packages/superdoc/dist/chunks/detect-container-Mk-wjDRB.es.js
+var exports_detect_container_Mk_wjDRB_es = {};
+__export(exports_detect_container_Mk_wjDRB_es, {
+  detectContainerType: () => detectContainerType
+});
+var init_detect_container_Mk_wjDRB_es = __esm(() => {
+  init_detect_container_CstXTt5n_es();
+});
+
+// ../../packages/superdoc/dist/chunks/errors-CtyzHiH4.es.js
+var EditorError, InvalidStateError, NoSourcePathError, FileSystemNotAvailableError, DocumentLoadError, DocxEncryptionErrorCode, DocxEncryptionError;
+var init_errors_CtyzHiH4_es = __esm(() => {
+  EditorError = class extends Error {
+    constructor(message) {
+      super(message);
+      this.name = "EditorError";
+    }
+  };
+  InvalidStateError = class extends EditorError {
+    constructor(message) {
+      super(message);
+      this.name = "InvalidStateError";
+    }
+  };
+  NoSourcePathError = class extends EditorError {
+    constructor(message) {
+      super(message);
+      this.name = "NoSourcePathError";
+    }
+  };
+  FileSystemNotAvailableError = class extends EditorError {
+    constructor(message) {
+      super(message);
+      this.name = "FileSystemNotAvailableError";
+    }
+  };
+  DocumentLoadError = class extends EditorError {
+    constructor(message, cause) {
+      super(message);
+      this.name = "DocumentLoadError";
+      this.cause = cause;
+    }
+  };
+  DocxEncryptionErrorCode = {
+    PASSWORD_REQUIRED: "DOCX_PASSWORD_REQUIRED",
+    PASSWORD_INVALID: "DOCX_PASSWORD_INVALID",
+    ENCRYPTION_UNSUPPORTED: "DOCX_ENCRYPTION_UNSUPPORTED",
+    DECRYPTION_FAILED: "DOCX_DECRYPTION_FAILED"
+  };
+  DocxEncryptionError = class extends EditorError {
+    constructor(code6, message, cause) {
+      super(message);
+      this.name = "DocxEncryptionError";
+      this.code = code6;
+      this.cause = cause;
+    }
+  };
+});
+
+// ../../packages/superdoc/dist/chunks/decrypt-docx-CNtHeQDp.es.js
+var exports_decrypt_docx_CNtHeQDp_es = {};
+__export(exports_decrypt_docx_CNtHeQDp_es, {
+  decryptDocxIfNeeded: () => decryptDocxIfNeeded
+});
+function concatUint8Arrays(chunks) {
+  const totalLength = chunks.reduce((sum, chunk2) => sum + chunk2.length, 0);
+  const result = new Uint8Array(totalLength);
+  let offset = 0;
+  for (const chunk2 of chunks) {
+    result.set(chunk2, offset);
+    offset += chunk2.length;
+  }
+  return result;
+}
+function getSectorOffset(sectorId, sectorSize) {
+  return (sectorId + 1) * sectorSize;
+}
+function readUint16LE$1(view, offset) {
+  return view.getUint16(offset, true);
+}
+function readUint32LE(view, offset) {
+  return view.getUint32(offset, true);
+}
+function readUint64LE(view, offset) {
+  const low = BigInt(view.getUint32(offset, true));
+  return BigInt(view.getUint32(offset + 4, true)) << 32n | low;
+}
+function decodeUtf16Le(bytes) {
+  return utf16LeDecoder.decode(bytes).replace(/\u0000+$/g, "");
+}
+function createDataView(bytes) {
+  return new DataView(bytes.buffer, bytes.byteOffset, bytes.byteLength);
+}
+function ensureAvailable(bytes, offset, length3, label) {
+  if (offset < 0 || length3 < 0 || offset + length3 > bytes.length)
+    throw new Error(`CFB ${label} exceeds available data`);
+}
+function parseHeader(bytes) {
+  if (bytes.length < 512)
+    throw new Error(`CFB header is truncated (${bytes.length} bytes)`);
+  for (let i4 = 0;i4 < CFB_SIGNATURE.length; i4++)
+    if (bytes[i4] !== CFB_SIGNATURE[i4])
+      throw new Error("Invalid CFB signature");
+  const view = createDataView(bytes);
+  const majorVersion = readUint16LE$1(view, 26);
+  const byteOrder = readUint16LE$1(view, 28);
+  const sectorShift = readUint16LE$1(view, 30);
+  const miniSectorShift = readUint16LE$1(view, 32);
+  const sectorSize = 1 << sectorShift;
+  const miniSectorSize = 1 << miniSectorShift;
+  if (byteOrder !== 65534)
+    throw new Error(`Unsupported CFB byte order: 0x${byteOrder.toString(16)}`);
+  if (!(majorVersion === 3 && sectorSize === 512 || majorVersion === 4 && sectorSize === 4096))
+    throw new Error(`Unsupported CFB major version ${majorVersion} with sector size ${sectorSize}`);
+  const difatEntries = [];
+  for (let i4 = 0;i4 < 109; i4++) {
+    const sectorId = readUint32LE(view, 76 + i4 * 4);
+    if (sectorId !== 4294967295)
+      difatEntries.push(sectorId);
+  }
+  return {
+    sectorSize,
+    miniSectorSize,
+    numberOfFatSectors: readUint32LE(view, 44),
+    firstDirectorySector: readUint32LE(view, 48),
+    miniStreamCutoffSize: readUint32LE(view, 56),
+    firstMiniFatSector: readUint32LE(view, 60),
+    numberOfMiniFatSectors: readUint32LE(view, 64),
+    firstDifatSector: readUint32LE(view, 68),
+    numberOfDifatSectors: readUint32LE(view, 72),
+    difatEntries
+  };
+}
+function readSector(bytes, header, sectorId) {
+  if (sectorId >= 4294967292)
+    throw new Error(`Invalid sector id 0x${sectorId.toString(16)}`);
+  const offset = getSectorOffset(sectorId, header.sectorSize);
+  ensureAvailable(bytes, offset, header.sectorSize, `sector ${sectorId}`);
+  return bytes.subarray(offset, offset + header.sectorSize);
+}
+function readDifatEntries(bytes, header) {
+  const difatEntries = [...header.difatEntries];
+  let nextDifatSector = header.firstDifatSector;
+  for (let i4 = 0;i4 < header.numberOfDifatSectors; i4++) {
+    if (nextDifatSector === 4294967294 || nextDifatSector === 4294967295)
+      break;
+    const view = createDataView(readSector(bytes, header, nextDifatSector));
+    const entriesPerDifatSector = header.sectorSize / 4 - 1;
+    for (let entryIndex = 0;entryIndex < entriesPerDifatSector; entryIndex++) {
+      const fatSectorId = readUint32LE(view, entryIndex * 4);
+      if (fatSectorId !== 4294967295)
+        difatEntries.push(fatSectorId);
+    }
+    nextDifatSector = readUint32LE(view, header.sectorSize - 4);
+  }
+  if (difatEntries.length < header.numberOfFatSectors)
+    throw new Error(`CFB DIFAT only exposed ${difatEntries.length} FAT sectors, expected ${header.numberOfFatSectors}`);
+  return difatEntries.slice(0, header.numberOfFatSectors);
+}
+function readFat(bytes, header) {
+  const fatSectorIds = readDifatEntries(bytes, header);
+  const fatEntries = [];
+  for (const fatSectorId of fatSectorIds) {
+    const view = createDataView(readSector(bytes, header, fatSectorId));
+    const entriesPerSector = header.sectorSize / 4;
+    for (let i4 = 0;i4 < entriesPerSector; i4++)
+      fatEntries.push(readUint32LE(view, i4 * 4));
+  }
+  return fatEntries;
+}
+function readSectorChain(bytes, header, fat, startSector) {
+  if (startSector === 4294967294 || startSector === 4294967295)
+    return new Uint8Array(0);
+  const chunks = [];
+  const visited = /* @__PURE__ */ new Set;
+  let sectorId = startSector;
+  while (sectorId !== CFB_END_OF_CHAIN) {
+    if (visited.has(sectorId))
+      throw new Error(`CFB sector chain loop detected at sector ${sectorId}`);
+    if (sectorId >= fat.length)
+      throw new Error(`CFB sector ${sectorId} is out of FAT bounds`);
+    visited.add(sectorId);
+    chunks.push(readSector(bytes, header, sectorId));
+    const nextSector = fat[sectorId];
+    if (nextSector == null)
+      throw new Error(`CFB FAT missing next sector for sector ${sectorId}`);
+    sectorId = nextSector;
+  }
+  return concatUint8Arrays(chunks);
+}
+function parseStreamSize(view, offset) {
+  const streamSize = readUint64LE(view, offset);
+  if (streamSize > BigInt(Number.MAX_SAFE_INTEGER))
+    throw new Error(`CFB stream is too large to fit in a JavaScript number: ${streamSize.toString()}`);
+  return Number(streamSize);
+}
+function parseDirectoryEntries(directoryBytes) {
+  const entries2 = [];
+  for (let offset = 0;offset + 128 <= directoryBytes.length; offset += 128) {
+    const slice2 = directoryBytes.subarray(offset, offset + 128);
+    const view = createDataView(slice2);
+    const nameLength = readUint16LE$1(view, 64);
+    const rawNameBytes = slice2.subarray(0, Math.max(0, Math.min(nameLength, 64) - 2));
+    entries2.push({
+      name: decodeUtf16Le(rawNameBytes),
+      objectType: slice2[66],
+      leftSiblingId: readUint32LE(view, 68),
+      rightSiblingId: readUint32LE(view, 72),
+      childId: readUint32LE(view, 76),
+      startSector: readUint32LE(view, 116),
+      streamSize: parseStreamSize(view, 120)
+    });
+  }
+  return entries2;
+}
+function forEachSiblingTree(entries2, entryId, visitor, visited = /* @__PURE__ */ new Set) {
+  if (entryId === 4294967295)
+    return false;
+  if (entryId >= entries2.length)
+    throw new Error(`CFB directory entry id ${entryId} is out of bounds`);
+  if (visited.has(entryId))
+    throw new Error(`CFB directory tree loop detected at entry id ${entryId}`);
+  visited.add(entryId);
+  const entry = entries2[entryId];
+  if (forEachSiblingTree(entries2, entry.leftSiblingId, visitor, visited))
+    return true;
+  if (visitor(entry) === true)
+    return true;
+  if (forEachSiblingTree(entries2, entry.rightSiblingId, visitor, visited))
+    return true;
+  return false;
+}
+function findEntryByPath(entries2, path2) {
+  const components = path2.split("/").map((component) => component.trim()).filter(Boolean);
+  let currentEntry = entries2[0];
+  for (const component of components) {
+    if (currentEntry.objectType !== CFB_OBJECT_TYPE.ROOT && currentEntry.objectType !== CFB_OBJECT_TYPE.STORAGE)
+      return null;
+    let nextEntry = null;
+    forEachSiblingTree(entries2, currentEntry.childId, (candidate) => {
+      if (candidate.name.toLowerCase() === component.toLowerCase()) {
+        nextEntry = candidate;
+        return true;
+      }
+      return false;
+    });
+    if (!nextEntry)
+      return null;
+    currentEntry = nextEntry;
+  }
+  return currentEntry;
+}
+function readMiniStream(rootEntry, bytes, header, fat) {
+  if (rootEntry.streamSize === 0 || rootEntry.startSector === 4294967294)
+    return new Uint8Array(0);
+  return readSectorChain(bytes, header, fat, rootEntry.startSector).subarray(0, rootEntry.streamSize);
+}
+function readMiniFat(bytes, header, fat) {
+  if (header.numberOfMiniFatSectors === 0 || header.firstMiniFatSector === 4294967294)
+    return [];
+  const miniFatBytes = readSectorChain(bytes, header, fat, header.firstMiniFatSector);
+  const view = createDataView(miniFatBytes);
+  const entryCount = Math.floor(miniFatBytes.length / 4);
+  const entries2 = [];
+  for (let i4 = 0;i4 < entryCount; i4++)
+    entries2.push(readUint32LE(view, i4 * 4));
+  return entries2;
+}
+function readMiniSectorChain(miniStream, miniFat, miniSectorSize, startSector) {
+  if (startSector === 4294967294 || startSector === 4294967295)
+    return new Uint8Array(0);
+  const chunks = [];
+  const visited = /* @__PURE__ */ new Set;
+  let sectorId = startSector;
+  while (sectorId !== CFB_END_OF_CHAIN) {
+    if (visited.has(sectorId))
+      throw new Error(`CFB mini sector chain loop detected at mini sector ${sectorId}`);
+    if (sectorId >= miniFat.length)
+      throw new Error(`CFB mini sector ${sectorId} is out of MiniFAT bounds`);
+    visited.add(sectorId);
+    const offset = sectorId * miniSectorSize;
+    ensureAvailable(miniStream, offset, miniSectorSize, `mini sector ${sectorId}`);
+    chunks.push(miniStream.subarray(offset, offset + miniSectorSize));
+    const nextSector = miniFat[sectorId];
+    if (nextSector == null)
+      throw new Error(`CFB MiniFAT missing next sector for mini sector ${sectorId}`);
+    sectorId = nextSector;
+  }
+  return concatUint8Arrays(chunks);
+}
+function createCfbReader(data) {
+  const bytes = data instanceof Uint8Array ? data : new Uint8Array(data);
+  const header = parseHeader(bytes);
+  const fat = readFat(bytes, header);
+  const directoryEntries = parseDirectoryEntries(readSectorChain(bytes, header, fat, header.firstDirectorySector));
+  if (directoryEntries.length === 0 || directoryEntries[0].objectType !== CFB_OBJECT_TYPE.ROOT)
+    throw new Error("CFB root directory entry is missing");
+  const rootEntry = directoryEntries[0];
+  const miniFat = readMiniFat(bytes, header, fat);
+  const miniStream = readMiniStream(rootEntry, bytes, header, fat);
+  return { getStream(path2) {
+    const entry = findEntryByPath(directoryEntries, path2);
+    if (!entry || entry.objectType !== CFB_OBJECT_TYPE.STREAM)
+      return null;
+    if (entry.streamSize < header.miniStreamCutoffSize)
+      return readMiniSectorChain(miniStream, miniFat, header.miniSectorSize, entry.startSector).subarray(0, entry.streamSize);
+    return readSectorChain(bytes, header, fat, entry.startSector).subarray(0, entry.streamSize);
+  } };
+}
+function extractEncryptionStreams(data) {
+  const bytes = data instanceof Uint8Array ? data : new Uint8Array(data);
+  let reader;
+  try {
+    reader = createCfbReader(bytes);
+  } catch (err) {
+    throw new DocxEncryptionError(DocxEncryptionErrorCode.DECRYPTION_FAILED, "Failed to parse OLE/CFB container", err instanceof Error ? err : undefined);
+  }
+  const encryptionInfo = reader.getStream("/EncryptionInfo");
+  if (!encryptionInfo)
+    throw new DocxEncryptionError(DocxEncryptionErrorCode.DECRYPTION_FAILED, "CFB container missing EncryptionInfo stream");
+  const encryptedPackage = reader.getStream("/EncryptedPackage");
+  if (!encryptedPackage)
+    throw new DocxEncryptionError(DocxEncryptionErrorCode.DECRYPTION_FAILED, "CFB container missing EncryptedPackage stream");
+  return {
+    encryptionInfo,
+    encryptedPackage
+  };
+}
+function readUint16LE(data, offset) {
+  return data[offset] | data[offset + 1] << 8;
+}
+function extractElementAttrs(xml, localName) {
+  const tagPattern = /* @__PURE__ */ new RegExp(`<(?:\\w+:)?${localName}\\b([^>]*)/?>`);
+  const match = xml.match(tagPattern);
+  if (!match)
+    return null;
+  const attrs = {};
+  const attrPattern = /(\w+)="([^"]*)"/g;
+  let attrMatch;
+  while ((attrMatch = attrPattern.exec(match[1])) !== null)
+    attrs[attrMatch[1]] = attrMatch[2];
+  return attrs;
+}
+function base64ToBytes(b64) {
+  if (typeof atob === "function") {
+    const raw = atob(b64);
+    const bytes = new Uint8Array(raw.length);
+    for (let i4 = 0;i4 < raw.length; i4++)
+      bytes[i4] = raw.charCodeAt(i4);
+    return bytes;
+  }
+  return new Uint8Array(Buffer3.from(b64, "base64"));
+}
+function requireAttr(attrs, name, label) {
+  const value = attrs?.[name];
+  if (value == null)
+    throw new DocxEncryptionError(DocxEncryptionErrorCode.DECRYPTION_FAILED, `Missing required attribute "${name}" on <${label}>`);
+  return value;
+}
+function requireBase64Attr(attrs, name, label) {
+  return base64ToBytes(requireAttr(attrs, name, label));
+}
+function requireIntAttr(attrs, name, label) {
+  const value = parseInt(requireAttr(attrs, name, label), 10);
+  if (Number.isNaN(value))
+    throw new DocxEncryptionError(DocxEncryptionErrorCode.DECRYPTION_FAILED, `Invalid integer for attribute "${name}" on <${label}>`);
+  return value;
+}
+function parseAgileXml(xmlBytes) {
+  const xml = new TextDecoder("utf-8").decode(xmlBytes);
+  const keyData = extractElementAttrs(xml, "keyData");
+  const dataIntegrity = extractElementAttrs(xml, "dataIntegrity");
+  const encryptedKey = extractElementAttrs(xml, "encryptedKey");
+  return {
+    keySalt: requireBase64Attr(keyData, "saltValue", "keyData"),
+    keyBits: requireIntAttr(keyData, "keyBits", "keyData"),
+    hashAlgorithm: requireAttr(keyData, "hashAlgorithm", "keyData"),
+    hashSize: requireIntAttr(keyData, "hashSize", "keyData"),
+    blockSize: requireIntAttr(keyData, "blockSize", "keyData"),
+    cipherAlgorithm: requireAttr(keyData, "cipherAlgorithm", "keyData"),
+    cipherChaining: requireAttr(keyData, "cipherChaining", "keyData"),
+    spinCount: requireIntAttr(encryptedKey, "spinCount", "encryptedKey"),
+    passwordSalt: requireBase64Attr(encryptedKey, "saltValue", "encryptedKey"),
+    passwordHashAlgorithm: requireAttr(encryptedKey, "hashAlgorithm", "encryptedKey"),
+    passwordKeyBits: requireIntAttr(encryptedKey, "keyBits", "encryptedKey"),
+    passwordBlockSize: requireIntAttr(encryptedKey, "blockSize", "encryptedKey"),
+    encryptedVerifierHashInput: requireBase64Attr(encryptedKey, "encryptedVerifierHashInput", "encryptedKey"),
+    encryptedVerifierHashValue: requireBase64Attr(encryptedKey, "encryptedVerifierHashValue", "encryptedKey"),
+    encryptedKeyValue: requireBase64Attr(encryptedKey, "encryptedKeyValue", "encryptedKey"),
+    encryptedHmacKey: requireBase64Attr(dataIntegrity, "encryptedHmacKey", "dataIntegrity"),
+    encryptedHmacValue: requireBase64Attr(dataIntegrity, "encryptedHmacValue", "dataIntegrity")
+  };
+}
+function parseEncryptionInfo(data) {
+  if (data.length < MIN_HEADER_SIZE)
+    throw new DocxEncryptionError(DocxEncryptionErrorCode.DECRYPTION_FAILED, `EncryptionInfo too short: ${data.length} bytes (minimum ${MIN_HEADER_SIZE})`);
+  const version3 = readUint16LE(data, 0);
+  const reserved = readUint16LE(data, 2);
+  if (version3 === AGILE_VERSION && reserved === AGILE_RESERVED)
+    return {
+      type: "agile",
+      params: parseAgileXml(data.subarray(MIN_HEADER_SIZE))
+    };
+  if ((version3 === STANDARD_VERSION_3 || version3 === STANDARD_VERSION_4) && reserved === STANDARD_RESERVED)
+    throw new DocxEncryptionError(DocxEncryptionErrorCode.ENCRYPTION_UNSUPPORTED, "Standard Encryption (Office 2007) is not yet supported. Only Agile Encryption (Office 2010+) is supported.");
+  if (version3 <= 2)
+    throw new DocxEncryptionError(DocxEncryptionErrorCode.ENCRYPTION_UNSUPPORTED, "Legacy RC4 encryption is not supported. Only Agile Encryption (Office 2010+) is supported.");
+  throw new DocxEncryptionError(DocxEncryptionErrorCode.ENCRYPTION_UNSUPPORTED, `Unrecognized EncryptionInfo version=${version3} reserved=${reserved}`);
+}
+function getSubtleCrypto() {
+  const subtle2 = globalThis.crypto?.subtle;
+  if (!subtle2)
+    throw new DocxEncryptionError(DocxEncryptionErrorCode.DECRYPTION_FAILED, "Web Crypto API (SubtleCrypto) is not available in this environment");
+  return subtle2;
+}
+function toWebCryptoHash(ooxmlName) {
+  const mapped = {
+    SHA1: "SHA-1",
+    "SHA-1": "SHA-1",
+    SHA256: "SHA-256",
+    "SHA-256": "SHA-256",
+    SHA384: "SHA-384",
+    "SHA-384": "SHA-384",
+    SHA512: "SHA-512",
+    "SHA-512": "SHA-512"
+  }[ooxmlName];
+  if (!mapped)
+    throw new DocxEncryptionError(DocxEncryptionErrorCode.DECRYPTION_FAILED, `Unsupported hash algorithm: ${ooxmlName}`);
+  return mapped;
+}
+function encodeUtf16le(str) {
+  const buf = new Uint8Array(str.length * 2);
+  for (let i4 = 0;i4 < str.length; i4++) {
+    const code6 = str.charCodeAt(i4);
+    buf[i4 * 2] = code6 & 255;
+    buf[i4 * 2 + 1] = code6 >> 8 & 255;
+  }
+  return buf;
+}
+function concat(...arrays) {
+  const totalLength = arrays.reduce((sum, a) => sum + a.length, 0);
+  const result = new Uint8Array(totalLength);
+  let offset = 0;
+  for (const arr of arrays) {
+    result.set(arr, offset);
+    offset += arr.length;
+  }
+  return result;
+}
+function uint32LE(value) {
+  const buf = new Uint8Array(4);
+  buf[0] = value & 255;
+  buf[1] = value >>> 8 & 255;
+  buf[2] = value >>> 16 & 255;
+  buf[3] = value >>> 24 & 255;
+  return buf;
+}
+function toBuffer(arr) {
+  return arr.buffer.slice(arr.byteOffset, arr.byteOffset + arr.byteLength);
+}
+async function hash(algorithm, data) {
+  const digest = await getSubtleCrypto().digest(algorithm, toBuffer(data));
+  return new Uint8Array(digest);
+}
+async function decryptAesCbc(keyBytes, iv, ciphertext) {
+  const subtle2 = getSubtleCrypto();
+  const blockSize = 16;
+  const key = await subtle2.importKey("raw", toBuffer(keyBytes), { name: "AES-CBC" }, false, ["encrypt", "decrypt"]);
+  const lastBlock = ciphertext.subarray(ciphertext.length - blockSize);
+  const pkcs7Plaintext = new Uint8Array(blockSize);
+  pkcs7Plaintext.fill(blockSize);
+  const paddingBlock = new Uint8Array(await subtle2.encrypt({
+    name: "AES-CBC",
+    iv: toBuffer(lastBlock)
+  }, key, pkcs7Plaintext)).subarray(0, blockSize);
+  const withPadding = new Uint8Array(ciphertext.length + blockSize);
+  withPadding.set(ciphertext);
+  withPadding.set(paddingBlock, ciphertext.length);
+  const decrypted = await subtle2.decrypt({
+    name: "AES-CBC",
+    iv: toBuffer(iv)
+  }, key, withPadding);
+  return new Uint8Array(decrypted).subarray(0, ciphertext.length);
+}
+async function deriveKey(password, salt, spinCount, keyBits, hashAlgorithm, blockKey) {
+  const algo = toWebCryptoHash(hashAlgorithm);
+  let h = await hash(algo, concat(salt, encodeUtf16le(password)));
+  for (let i4 = 0;i4 < spinCount; i4++)
+    h = await hash(algo, concat(uint32LE(i4), h));
+  const hDerived = await hash(algo, concat(h, blockKey));
+  const requiredBytes = keyBits / 8;
+  if (hDerived.length >= requiredBytes)
+    return hDerived.subarray(0, requiredBytes);
+  const padded = new Uint8Array(requiredBytes);
+  padded.set(hDerived);
+  padded.fill(54, hDerived.length);
+  return padded;
+}
+async function generateIV(hashAlgorithm, salt, blockKey, blockSize) {
+  let ivSource;
+  if (blockKey)
+    ivSource = await hash(toWebCryptoHash(hashAlgorithm), concat(salt, blockKey));
+  else
+    ivSource = salt;
+  if (ivSource.length >= blockSize)
+    return ivSource.subarray(0, blockSize);
+  const padded = new Uint8Array(blockSize);
+  padded.set(ivSource);
+  padded.fill(54, ivSource.length);
+  return padded;
+}
+async function verifyPasswordAndGetKey(password, params3) {
+  const { passwordSalt, spinCount, passwordHashAlgorithm, passwordKeyBits, passwordBlockSize } = params3;
+  const keyVerifierInput = await deriveKey(password, passwordSalt, spinCount, passwordKeyBits, passwordHashAlgorithm, BLOCK_KEY_VERIFIER_INPUT);
+  const keyVerifierValue = await deriveKey(password, passwordSalt, spinCount, passwordKeyBits, passwordHashAlgorithm, BLOCK_KEY_VERIFIER_VALUE);
+  const keyEncryptedKey = await deriveKey(password, passwordSalt, spinCount, passwordKeyBits, passwordHashAlgorithm, BLOCK_KEY_ENCRYPTED_KEY);
+  const passwordVerifierIv = await generateIV(passwordHashAlgorithm, passwordSalt, undefined, passwordBlockSize);
+  const verifierHashInput = await decryptAesCbc(keyVerifierInput, passwordVerifierIv, params3.encryptedVerifierHashInput);
+  const verifierHashValue = await decryptAesCbc(keyVerifierValue, passwordVerifierIv, params3.encryptedVerifierHashValue);
+  const computedHash = await hash(toWebCryptoHash(passwordHashAlgorithm), verifierHashInput);
+  if (!constantTimeEqual(computedHash, verifierHashValue.subarray(0, computedHash.length)))
+    throw new DocxEncryptionError(DocxEncryptionErrorCode.PASSWORD_INVALID, "The password is incorrect");
+  return decryptAesCbc(keyEncryptedKey, passwordVerifierIv, params3.encryptedKeyValue);
+}
+function constantTimeEqual(a, b) {
+  if (a.length !== b.length)
+    return false;
+  let diff = 0;
+  for (let i4 = 0;i4 < a.length; i4++)
+    diff |= a[i4] ^ b[i4];
+  return diff === 0;
+}
+async function decryptPackageSegments(encryptionKey, params3, encryptedPackage) {
+  const { keySalt, hashAlgorithm, blockSize } = params3;
+  const algo = toWebCryptoHash(hashAlgorithm);
+  if (encryptedPackage.length < PACKAGE_HEADER_SIZE)
+    throw new DocxEncryptionError(DocxEncryptionErrorCode.DECRYPTION_FAILED, "EncryptedPackage too short to contain size header");
+  const plaintextSize = encryptedPackage[0] | encryptedPackage[1] << 8 | encryptedPackage[2] << 16 | encryptedPackage[3] << 24 >>> 0;
+  const encryptedData = encryptedPackage.subarray(PACKAGE_HEADER_SIZE);
+  const segmentCount = Math.ceil(encryptedData.length / SEGMENT_SIZE);
+  const decryptedChunks = [];
+  for (let i4 = 0;i4 < segmentCount; i4++) {
+    const segmentStart = i4 * SEGMENT_SIZE;
+    const segmentEnd = Math.min(segmentStart + SEGMENT_SIZE, encryptedData.length);
+    const segment = encryptedData.subarray(segmentStart, segmentEnd);
+    const ivHash = await hash(algo, concat(keySalt, uint32LE(i4)));
+    const decrypted = await decryptAesCbc(encryptionKey, ivHash.length >= blockSize ? ivHash.subarray(0, blockSize) : ivHash, segment);
+    decryptedChunks.push(decrypted);
+  }
+  return concat(...decryptedChunks).subarray(0, plaintextSize);
+}
+async function verifyDataIntegrity(encryptionKey, params3, encryptedPackage) {
+  const { keySalt, hashAlgorithm, blockSize, hashSize } = params3;
+  const algo = toWebCryptoHash(hashAlgorithm);
+  const subtle2 = getSubtleCrypto();
+  const hmacKey = (await decryptAesCbc(encryptionKey, await generateIV(hashAlgorithm, keySalt, BLOCK_KEY_HMAC_KEY, blockSize), params3.encryptedHmacKey)).subarray(0, hashSize);
+  const expectedHmac = await decryptAesCbc(encryptionKey, await generateIV(hashAlgorithm, keySalt, BLOCK_KEY_HMAC_VALUE, blockSize), params3.encryptedHmacValue);
+  const cryptoKey = await subtle2.importKey("raw", toBuffer(hmacKey), {
+    name: "HMAC",
+    hash: algo
+  }, false, ["sign"]);
+  const computedHmac = new Uint8Array(await subtle2.sign("HMAC", cryptoKey, toBuffer(encryptedPackage)));
+  if (!constantTimeEqual(computedHmac, expectedHmac.subarray(0, computedHmac.length)))
+    throw new DocxEncryptionError(DocxEncryptionErrorCode.DECRYPTION_FAILED, "Data integrity check failed — the encrypted package may be corrupt or tampered with");
+}
+async function decryptAgilePackage(password, params3, encryptedPackage) {
+  try {
+    const encryptionKey = await verifyPasswordAndGetKey(password, params3);
+    await verifyDataIntegrity(encryptionKey, params3, encryptedPackage);
+    return await decryptPackageSegments(encryptionKey, params3, encryptedPackage);
+  } catch (err) {
+    if (err instanceof DocxEncryptionError)
+      throw err;
+    throw new DocxEncryptionError(DocxEncryptionErrorCode.DECRYPTION_FAILED, "Decryption failed unexpectedly", err instanceof Error ? err : undefined);
+  }
+}
+function validateDecryptedOutput(data) {
+  if (detectContainerType(data) !== "zip")
+    throw new DocxEncryptionError(DocxEncryptionErrorCode.DECRYPTION_FAILED, "Decrypted output is not a valid ZIP archive — the file may be corrupt");
+}
+async function decryptDocxIfNeeded(data, options) {
+  const bytes = data instanceof Uint8Array ? data : new Uint8Array(data);
+  const containerType = detectContainerType(bytes);
+  if (containerType === "zip")
+    return {
+      data: bytes,
+      wasEncrypted: false
+    };
+  if (containerType === "unknown")
+    throw new DocxEncryptionError(DocxEncryptionErrorCode.DECRYPTION_FAILED, "Unrecognized file format — expected a .docx (ZIP) or encrypted .docx (OLE/CFB)");
+  if (!options?.password)
+    throw new DocxEncryptionError(DocxEncryptionErrorCode.PASSWORD_REQUIRED, "This document is password-protected. A password is required to open it.");
+  const streams = extractEncryptionStreams(bytes);
+  const { params: params3 } = parseEncryptionInfo(streams.encryptionInfo);
+  const decryptedZip = await decryptAgilePackage(options.password, params3, streams.encryptedPackage);
+  validateDecryptedOutput(decryptedZip);
+  return {
+    data: decryptedZip,
+    wasEncrypted: true
+  };
+}
+var CFB_SIGNATURE, CFB_END_OF_CHAIN = 4294967294, CFB_OBJECT_TYPE, utf16LeDecoder, AGILE_VERSION = 4, AGILE_RESERVED = 4, STANDARD_VERSION_3 = 3, STANDARD_VERSION_4 = 4, STANDARD_RESERVED = 3, MIN_HEADER_SIZE = 8, BLOCK_KEY_VERIFIER_INPUT, BLOCK_KEY_VERIFIER_VALUE, BLOCK_KEY_ENCRYPTED_KEY, BLOCK_KEY_HMAC_KEY, BLOCK_KEY_HMAC_VALUE, SEGMENT_SIZE = 4096, PACKAGE_HEADER_SIZE = 8;
+var init_decrypt_docx_CNtHeQDp_es = __esm(() => {
+  init_dist_Cwvmda4Q_es();
+  init_errors_CtyzHiH4_es();
+  init_detect_container_CstXTt5n_es();
+  CFB_SIGNATURE = new Uint8Array([
+    208,
+    207,
+    17,
+    224,
+    161,
+    177,
+    26,
+    225
+  ]);
+  CFB_OBJECT_TYPE = {
+    STORAGE: 1,
+    STREAM: 2,
+    ROOT: 5
+  };
+  utf16LeDecoder = new TextDecoder("utf-16le");
+  BLOCK_KEY_VERIFIER_INPUT = new Uint8Array([
+    254,
+    167,
+    210,
+    118,
+    59,
+    75,
+    158,
+    121
+  ]);
+  BLOCK_KEY_VERIFIER_VALUE = new Uint8Array([
+    215,
+    170,
+    15,
+    109,
+    48,
+    97,
+    52,
+    78
+  ]);
+  BLOCK_KEY_ENCRYPTED_KEY = new Uint8Array([
+    20,
+    110,
+    11,
+    231,
+    171,
+    172,
+    208,
+    214
+  ]);
+  BLOCK_KEY_HMAC_KEY = new Uint8Array([
+    95,
+    178,
+    173,
+    1,
+    12,
+    185,
+    225,
+    246
+  ]);
+  BLOCK_KEY_HMAC_VALUE = new Uint8Array([
+    160,
+    103,
+    127,
+    2,
+    178,
+    44,
+    132,
+    51
+  ]);
+});
+
+// ../../packages/superdoc/dist/chunks/DocxZipper-DvDGw347.es.js
+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 i4 = 0;i4 < Math.min(64, u8.length); i4++)
+    if (u8[i4] === 0)
+      nul++;
+  if (nul > 16)
+    return "utf-16le";
+  return "utf-8";
+}
+function stripBOM(str) {
+  return str && str.charCodeAt(0) === 65279 ? str.slice(1) : str;
+}
+function ensureXmlString(content2) {
+  if (typeof content2 === "string")
+    return stripBOM(content2);
+  let u8 = null;
+  if (content2 && typeof content2 === "object") {
+    if (content2 instanceof Uint8Array)
+      u8 = content2;
+    else if (typeof Buffer3 !== "undefined" && Buffer3.isBuffer && Buffer3.isBuffer(content2))
+      u8 = new Uint8Array(content2.buffer, content2.byteOffset, content2.byteLength);
+    else if (ArrayBuffer.isView && ArrayBuffer.isView(content2))
+      u8 = new Uint8Array(content2.buffer, content2.byteOffset, content2.byteLength);
+    else if (content2.constructor && (content2 instanceof ArrayBuffer || content2.constructor.name === "ArrayBuffer"))
+      u8 = new Uint8Array(content2);
+  }
+  if (!u8)
+    throw new Error("Unsupported content type for XML");
+  const enc = sniffEncoding(u8);
+  let xml = new TextDecoder(enc).decode(u8);
+  xml = stripBOM(xml);
+  if (enc !== "utf-8")
+    xml = xml.replace(/(<\?xml\b[^?]*?)\bencoding\s*=\s*["'][^"']*["']/i, '$1encoding="UTF-8"');
+  return xml;
+}
+function readEntry(path2, baseFiles, updatedDocs) {
+  if (updatedDocs && Object.prototype.hasOwnProperty.call(updatedDocs, path2))
+    return updatedDocs[path2];
+  if (!baseFiles)
+    return;
+  if (Array.isArray(baseFiles))
+    return baseFiles.find((f2) => f2.name === path2)?.content;
+  return baseFiles[path2];
+}
+function partExistsInPackage(zipPath, baseFiles, updatedDocs) {
+  return readEntry(zipPath, baseFiles, updatedDocs) != null;
+}
+function parseXml(xmlString) {
+  try {
+    return import_lib$2.xml2js(xmlString, { compact: false });
+  } catch {
+    return null;
+  }
+}
+function serializeXml(jsObject) {
+  return import_lib$2.js2xml(jsObject, { spaces: 0 });
+}
+function findRootElement(parsed, tagName) {
+  return parsed?.elements?.find((el) => {
+    if (!el.name)
+      return false;
+    return (el.name.includes(":") ? el.name.split(":").pop() : el.name) === tagName;
+  });
+}
+function createEmptyRels() {
+  return {
+    declaration: { attributes: {
+      version: "1.0",
+      encoding: "UTF-8",
+      standalone: "yes"
+    } },
+    elements: [{
+      type: "element",
+      name: "Relationships",
+      attributes: { xmlns: RELATIONSHIPS_NS },
+      elements: []
+    }]
+  };
+}
+function findMaxRId$1(relsRoot) {
+  let max4 = 0;
+  for (const el of relsRoot.elements || []) {
+    const id2 = el.attributes?.Id;
+    if (!id2)
+      continue;
+    const match = id2.match(/^rId(\d+)$/);
+    if (match)
+      max4 = Math.max(max4, parseInt(match[1], 10));
+  }
+  return max4;
+}
+function reconcileContentTypes(typesRoot, presentParts) {
+  if (!typesRoot.elements)
+    typesRoot.elements = [];
+  const managedByPartName = /* @__PURE__ */ new Map;
+  for (const entry of MANAGED_PACKAGE_PARTS)
+    managedByPartName.set(`/${entry.zipPath}`, entry);
+  const existingOverrides = /* @__PURE__ */ new Map;
+  for (let i4 = 0;i4 < typesRoot.elements.length; i4++) {
+    const el = typesRoot.elements[i4];
+    if (el.name !== "Override")
+      continue;
+    const partName = el.attributes?.PartName;
+    if (!partName || !managedByPartName.has(partName))
+      continue;
+    if (!existingOverrides.has(partName))
+      existingOverrides.set(partName, []);
+    existingOverrides.get(partName).push(i4);
+  }
+  const indicesToRemove = /* @__PURE__ */ new Set;
+  for (const [partName, entry] of managedByPartName) {
+    const isPresent = presentParts.has(entry.zipPath);
+    const indices = existingOverrides.get(partName) || [];
+    if (!isPresent) {
+      for (const idx of indices)
+        indicesToRemove.add(idx);
+      continue;
+    }
+    if (indices.length === 0)
+      typesRoot.elements.push({
+        type: "element",
+        name: "Override",
+        attributes: {
+          PartName: partName,
+          ContentType: entry.contentType
+        }
+      });
+    else {
+      typesRoot.elements[indices[0]].attributes.ContentType = entry.contentType;
+      for (let i4 = 1;i4 < indices.length; i4++)
+        indicesToRemove.add(indices[i4]);
+    }
+  }
+  if (indicesToRemove.size > 0) {
+    const sorted = [...indicesToRemove].sort((a, b) => b - a);
+    for (const idx of sorted)
+      typesRoot.elements.splice(idx, 1);
+  }
+}
+function reconcileRootRels(relsRoot, presentParts) {
+  if (!relsRoot.elements)
+    relsRoot.elements = [];
+  const managedByType = /* @__PURE__ */ new Map;
+  for (const entry of MANAGED_PACKAGE_PARTS)
+    managedByType.set(entry.relationshipType, entry);
+  const existingRels = /* @__PURE__ */ new Map;
+  for (let i4 = 0;i4 < relsRoot.elements.length; i4++) {
+    const el = relsRoot.elements[i4];
+    if (el.name !== "Relationship")
+      continue;
+    const type = el.attributes?.Type;
+    if (!type || !managedByType.has(type))
+      continue;
+    if (!existingRels.has(type))
+      existingRels.set(type, []);
+    existingRels.get(type).push({
+      index: i4,
+      element: el
+    });
+  }
+  const indicesToRemove = /* @__PURE__ */ new Set;
+  let maxRId = findMaxRId$1(relsRoot);
+  for (const [relType, entry] of managedByType) {
+    const isPresent = presentParts.has(entry.zipPath);
+    const existing = existingRels.get(relType) || [];
+    if (!isPresent) {
+      for (const { index: index2 } of existing)
+        indicesToRemove.add(index2);
+      continue;
+    }
+    if (existing.length === 0) {
+      maxRId++;
+      relsRoot.elements.push({
+        type: "element",
+        name: "Relationship",
+        attributes: {
+          Id: `rId${maxRId}`,
+          Type: relType,
+          Target: entry.zipPath
+        }
+      });
+    } else {
+      existing[0].element.attributes.Target = entry.zipPath;
+      for (let i4 = 1;i4 < existing.length; i4++)
+        indicesToRemove.add(existing[i4].index);
+    }
+  }
+  if (indicesToRemove.size > 0) {
+    const sorted = [...indicesToRemove].sort((a, b) => b - a);
+    for (const idx of sorted)
+      relsRoot.elements.splice(idx, 1);
+  }
+}
+function syncPackageMetadata({ baseFiles, updatedDocs }) {
+  const presentParts = /* @__PURE__ */ new Set;
+  for (const entry of MANAGED_PACKAGE_PARTS)
+    if (partExistsInPackage(entry.zipPath, baseFiles, updatedDocs))
+      presentParts.add(entry.zipPath);
+  const rawContentTypes = readEntry("[Content_Types].xml", baseFiles, updatedDocs);
+  if (rawContentTypes == null)
+    throw new Error("syncPackageMetadata: [Content_Types].xml is missing from the package. Cannot safely reconcile package metadata without an existing content types file.");
+  const contentTypesParsed = parseXml(rawContentTypes);
+  if (!contentTypesParsed)
+    throw new Error("syncPackageMetadata: [Content_Types].xml could not be parsed as valid XML. Cannot safely reconcile package metadata from a malformed content types file.");
+  const typesRoot = findRootElement(contentTypesParsed, "Types");
+  if (!typesRoot)
+    throw new Error("syncPackageMetadata: [Content_Types].xml does not contain a <Types> root element.");
+  reconcileContentTypes(typesRoot, presentParts);
+  const rawRels = readEntry("_rels/.rels", baseFiles, updatedDocs);
+  let relsParsed;
+  if (rawRels == null)
+    relsParsed = createEmptyRels();
+  else {
+    relsParsed = parseXml(rawRels);
+    if (!relsParsed)
+      throw new Error("syncPackageMetadata: _rels/.rels could not be parsed as valid XML. Cannot safely reconcile root relationships from a malformed rels file.");
+  }
+  let relsRoot = findRootElement(relsParsed, "Relationships");
+  if (!relsRoot) {
+    relsParsed = createEmptyRels();
+    relsRoot = relsParsed.elements[0];
+  }
+  reconcileRootRels(relsRoot, presentParts);
+  return {
+    contentTypesXml: serializeXml(contentTypesParsed),
+    relsXml: serializeXml(relsParsed)
+  };
+}
+function findMaxRId(elements) {
+  let max4 = 0;
+  for (const el of elements) {
+    const match = el.attributes?.Id?.match(/^rId(\d+)$/);
+    if (match)
+      max4 = Math.max(max4, Number(match[1]));
+  }
+  return max4;
+}
+function reconcileDocumentRelationships(relsXml, fileExists) {
+  if (!relsXml)
+    return relsXml;
+  let parsed;
+  try {
+    parsed = import_lib$12.xml2js(relsXml, { compact: false });
+  } catch {
+    return relsXml;
+  }
+  const relsTag = parsed?.elements?.find((el) => el.name === "Relationships");
+  if (!relsTag)
+    return relsXml;
+  if (!relsTag.elements)
+    relsTag.elements = [];
+  let changed = false;
+  let maxId = findMaxRId(relsTag.elements);
+  for (const entry of MANAGED_DOCUMENT_PARTS) {
+    if (!fileExists(entry.zipPath))
+      continue;
+    if (relsTag.elements.some((el) => el.attributes?.Type === entry.relationshipType))
+      continue;
+    maxId++;
+    relsTag.elements.push({
+      type: "element",
+      name: "Relationship",
+      attributes: {
+        Id: `rId${maxId}`,
+        Type: entry.relationshipType,
+        Target: entry.relTarget
+      }
+    });
+    changed = true;
+  }
+  if (!changed)
+    return relsXml;
+  return import_lib$12.js2xml(parsed, { spaces: 0 });
+}
+var DOCX = "application/vnd.openxmlformats-officedocument.wordprocessingml.document", isXmlLike = (name) => /\.xml$|\.rels$/i.test(name), MANAGED_PACKAGE_PARTS, import_lib$2, RELATIONSHIPS_NS = "http://schemas.openxmlformats.org/package/2006/relationships", import_lib$12, MANAGED_DOCUMENT_PARTS, import_lib3, import_jszip_min, IMAGE_EXTS, MIME_TYPE_FOR_EXT, CUSTOM_XML_ITEM_PROPS_CONTENT_TYPE = "application/vnd.openxmlformats-officedocument.customXmlProperties+xml", FONT_CONTENT_TYPES, DocxZipper = class {
+  constructor(params3 = {}) {
+    this.debug = params3.debug || false;
+    this.zip = new import_jszip_min.default;
+    this.files = [];
+    this.media = {};
+    this.mediaFiles = {};
+    this.fonts = {};
+    this.decryptedFileData = null;
+  }
+  async#peekBytes(file, n) {
+    if (file instanceof Uint8Array || typeof Buffer3 !== "undefined" && Buffer3.isBuffer(file))
+      return new Uint8Array(file.buffer, file.byteOffset, Math.min(n, file.byteLength));
+    if (file instanceof ArrayBuffer)
+      return new Uint8Array(file, 0, Math.min(n, file.byteLength));
+    if (typeof Blob !== "undefined" && file instanceof Blob)
+      try {
+        if (typeof file.arrayBuffer === "function") {
+          const buf = await file.arrayBuffer();
+          return new Uint8Array(buf, 0, Math.min(n, buf.byteLength));
+        }
+      } catch {}
+    return new Uint8Array(0);
+  }
+  async getDocxData(file, isNode3 = false, options = {}) {
+    const { detectContainerType: detectContainerType2 } = await Promise.resolve().then(() => (init_detect_container_Mk_wjDRB_es(), exports_detect_container_Mk_wjDRB_es));
+    const containerType = detectContainerType2(await this.#peekBytes(file, 8));
+    let fileData = file;
+    if (containerType === "cfb") {
+      const { decryptDocxIfNeeded: decryptDocxIfNeeded2 } = await Promise.resolve().then(() => (init_decrypt_docx_CNtHeQDp_es(), exports_decrypt_docx_CNtHeQDp_es));
+      const result = await decryptDocxIfNeeded2(file instanceof Uint8Array ? file : file instanceof ArrayBuffer ? new Uint8Array(file) : new Uint8Array(await file.arrayBuffer()), { password: options.password });
+      fileData = result.data;
+      this.decryptedFileData = result.data;
+    }
+    const extractedFiles = await this.unzip(fileData);
+    const files = Object.entries(extractedFiles.files);
+    for (const [, zipEntry] of files) {
+      const name = zipEntry.name;
+      if (isXmlLike(name)) {
+        const content2 = ensureXmlString(await zipEntry.async("uint8array"));
+        this.files.push({
+          name,
+          content: content2
+        });
+      } 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 (isNode3) {
+          const fileBase64 = (await zipEntry.async("nodebuffer")).toString("base64");
+          this.mediaFiles[name] = fileBase64;
+        } else {
+          const fileBase64 = await zipEntry.async("base64");
+          let extension2 = this.getFileExtension(name)?.toLowerCase();
+          let detectedType = null;
+          if (!IMAGE_EXTS.has(extension2) || extension2 === "tmp") {
+            detectedType = detectImageType(fileBase64);
+            if (detectedType)
+              extension2 = detectedType;
+          }
+          if (IMAGE_EXTS.has(extension2)) {
+            const mimeSubtype = MIME_TYPE_FOR_EXT[extension2] || extension2;
+            this.mediaFiles[name] = `data:image/${mimeSubtype};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 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 = {}, fonts = {}) {
+    const additionalPartNames = Object.keys(updatedDocs || {});
+    const newMediaTypes = Object.keys(media).map((name) => this.getFileExtension(name)).filter((ext) => ext && IMAGE_EXTS.has(ext));
+    const extensionlessMediaOverrides = Object.entries(media).filter(([name]) => !this.getFileExtension(name)).map(([name, value]) => ({
+      name,
+      contentType: this.#detectImageContentType(value)
+    })).filter((entry) => entry.contentType);
+    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 = 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/${MIME_TYPE_FOR_EXT[type] || type}"/>`;
+      typesString += newContentType;
+      seenTypes.add(type);
+    }
+    if (fonts) {
+      const fontExts = new Set(Object.keys(fonts).map((name) => this.getFileExtension(name)).filter((ext) => ext && FONT_CONTENT_TYPES[ext]));
+      for (const ext of fontExts) {
+        if (defaultMediaTypes.includes(ext))
+          continue;
+        if (seenTypes.has(ext))
+          continue;
+        typesString += `<Default Extension="${ext}" ContentType="${FONT_CONTENT_TYPES[ext]}"/>`;
+        seenTypes.add(ext);
+      }
+    }
+    const types3 = JSON.parse(import_lib3.xml2json(contentTypesXml, null, 2)).elements?.find((el) => el.name === "Types") || {};
+    const hasPartOverride = (partName) => types3.elements?.some((el) => el.name === "Override" && el.attributes.PartName === partName);
+    for (const { name, contentType } of extensionlessMediaOverrides) {
+      const partName = `/${name}`;
+      if (hasPartOverride(partName))
+        continue;
+      typesString += `<Override PartName="${partName}" ContentType="${contentType}" />`;
+    }
+    const hasComments = types3.elements?.some((el) => el.name === "Override" && el.attributes.PartName === "/word/comments.xml");
+    const hasCommentsExtended = types3.elements?.some((el) => el.name === "Override" && el.attributes.PartName === "/word/commentsExtended.xml");
+    const hasCommentsIds = types3.elements?.some((el) => el.name === "Override" && el.attributes.PartName === "/word/commentsIds.xml");
+    const hasCommentsExtensible = types3.elements?.some((el) => el.name === "Override" && el.attributes.PartName === "/word/commentsExtensible.xml");
+    const hasFile = (filename) => {
+      if (updatedDocs && Object.prototype.hasOwnProperty.call(updatedDocs, filename))
+        return updatedDocs[filename] !== null;
+      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]);
+    };
+    if (hasFile("word/comments.xml")) {
+      const commentsDef = `<Override PartName="/word/comments.xml" ContentType="application/vnd.openxmlformats-officedocument.wordprocessingml.comments+xml" />`;
+      if (!hasComments)
+        typesString += commentsDef;
+    }
+    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 = types3.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;
+    }
+    for (const entry of MANAGED_DOCUMENT_PARTS)
+      if (hasFile(entry.zipPath) && !hasPartOverride(`/${entry.zipPath}`))
+        typesString += `<Override PartName="/${entry.zipPath}" ContentType="${entry.contentType}" />`;
+    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 (!/^customXml\/itemProps\d+\.xml$/i.test(name))
+        return;
+      if (!hasFile(name))
+        return;
+      const partName = `/${name}`;
+      if (hasPartOverride(partName))
+        return;
+      typesString += `<Override PartName="${partName}" ContentType="${CUSTOM_XML_ITEM_PROPS_CONTENT_TYPE}" />`;
+    });
+    partNames.forEach((name) => {
+      if (name.includes(".rels"))
+        return;
+      if (!name.includes("header") && !name.includes("footer"))
+        return;
+      const hasExtensible = types3.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 staleOverridePartNames = COMMENT_FILE_BASENAMES.map((name) => `/word/${name}`).filter((partName) => {
+      return !hasFile(partName.slice(1));
+    });
+    const beginningString = '<Types xmlns="http://schemas.openxmlformats.org/package/2006/content-types">';
+    let updatedContentTypesXml = contentTypesXml.replace(beginningString, `${beginningString}${typesString}`);
+    for (const partName of staleOverridePartNames) {
+      const escapedPartName = partName.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+      const overrideRegex = new RegExp(`\\s*<Override[^>]*PartName="${escapedPartName}"[^>]*/>`, "g");
+      updatedContentTypesXml = updatedContentTypesXml.replace(overrideRegex, "");
+    }
+    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_lib3.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 (error3) {
+        console.warn("Failed to parse document relationships while updating content types", error3);
+      }
+    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 (relationshipsXml) {
+      const reconciledRels = reconcileDocumentRelationships(relationshipsXml, hasFile);
+      if (reconciledRels !== relationshipsXml)
+        if (fromJson)
+          updatedDocs["word/_rels/document.xml.rels"] = reconciledRels;
+        else
+          docx.file("word/_rels/document.xml.rels", reconciledRels);
+    }
+    if (fromJson)
+      return updatedContentTypesXml;
+    docx.file(contentTypesPath, updatedContentTypesXml);
+  }
+  async#syncPackageMetadataInZip(zip) {
+    const baseForSync = {};
+    zip.forEach((path2) => {
+      baseForSync[path2] = "";
+    });
+    const ctEntry = zip.file("[Content_Types].xml");
+    if (ctEntry)
+      baseForSync["[Content_Types].xml"] = await ctEntry.async("string");
+    const rlEntry = zip.file("_rels/.rels");
+    if (rlEntry)
+      baseForSync["_rels/.rels"] = await rlEntry.async("string");
+    const { contentTypesXml, relsXml } = syncPackageMetadata({
+      baseFiles: baseForSync,
+      updatedDocs: {}
+    });
+    zip.file("[Content_Types].xml", contentTypesXml);
+    zip.file("_rels/.rels", relsXml);
+  }
+  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, fonts);
+    else
+      zip = await this.exportFromCollaborativeDocx(docx, updatedDocs, media, fonts);
+    const exportType = isHeadless ? "nodebuffer" : "blob";
+    return await zip.generateAsync({
+      type: exportType,
+      mimeType: DOCX,
+      compression,
+      compressionOptions: compression === "DEFLATE" ? { level: 6 } : undefined
+    });
+  }
+  async exportFromCollaborativeDocx(docx, updatedDocs, media, fonts) {
+    if (!Array.isArray(docx))
+      throw new Error("Collaborative DOCX export requires base package entries");
+    const zip = new import_jszip_min.default;
+    for (const file of docx) {
+      const content2 = file.content;
+      zip.file(file.name, content2);
+    }
+    Object.keys(updatedDocs).forEach((key) => {
+      if (updatedDocs[key] === null)
+        zip.remove(key);
+      else
+        zip.file(key, updatedDocs[key]);
+    });
+    Object.keys(media).forEach((path2) => {
+      const value = media[path2];
+      const binaryData = typeof value === "string" ? base64ToUint8Array(value) : value;
+      zip.file(path2, binaryData);
+    });
+    for (const [fontName, fontUintArray] of Object.entries(fonts))
+      zip.file(fontName, fontUintArray);
+    await this.updateContentTypes(zip, media, false, updatedDocs, fonts);
+    await this.#syncPackageMetadataInZip(zip);
+    return zip;
+  }
+  async exportFromOriginalFile(originalDocxFile, updatedDocs, media, fonts) {
+    const unzippedOriginalDocx = await this.unzip(originalDocxFile);
+    const filePromises = [];
+    unzippedOriginalDocx.forEach((relativePath, zipEntry) => {
+      const promise = zipEntry.async("uint8array").then((u8) => {
+        unzippedOriginalDocx.file(zipEntry.name, isXmlLike(zipEntry.name) ? ensureXmlString(u8) : u8);
+      });
+      filePromises.push(promise);
+    });
+    await Promise.all(filePromises);
+    Object.keys(updatedDocs).forEach((key) => {
+      if (updatedDocs[key] === null)
+        unzippedOriginalDocx.remove(key);
+      else
+        unzippedOriginalDocx.file(key, updatedDocs[key]);
+    });
+    Object.keys(media).forEach((path2) => {
+      unzippedOriginalDocx.file(path2, media[path2]);
+    });
+    if (fonts)
+      for (const [fontName, fontUintArray] of Object.entries(fonts))
+        unzippedOriginalDocx.file(fontName, fontUintArray);
+    await this.updateContentTypes(unzippedOriginalDocx, media, false, updatedDocs, fonts);
+    await this.#syncPackageMetadataInZip(unzippedOriginalDocx);
+    return unzippedOriginalDocx;
+  }
+  #detectImageContentType(value) {
+    if (value == null)
+      return null;
+    if (typeof value === "string" && value.startsWith("data:image/"))
+      return value.match(/^data:(image\/[a-zA-Z0-9.+-]+);/i)?.[1]?.toLowerCase() || null;
+    let detectedType = null;
+    if (value instanceof ArrayBuffer)
+      detectedType = detectImageType(new Uint8Array(value));
+    else if (ArrayBuffer.isView(value))
+      detectedType = detectImageType(new Uint8Array(value.buffer, value.byteOffset, value.byteLength));
+    else if (typeof value === "string")
+      detectedType = detectImageType(value.startsWith("data:") ? value.split(",", 2)[1] : value);
+    if (!detectedType)
+      return null;
+    return `image/${MIME_TYPE_FOR_EXT[detectedType] || detectedType}`;
+  }
+}, DocxZipper_default;
+var init_DocxZipper_DvDGw347_es = __esm(() => {
+  init_rolldown_runtime_B2q5OVn9_es();
+  init_jszip_ChlR43oI_es();
+  init_xml_js_40FWvL78_es();
+  init_constants_Qqwopz80_es();
+  init_dist_Cwvmda4Q_es();
   MANAGED_PACKAGE_PARTS = [
     {
       zipPath: "word/document.xml",
@@ -152981,7 +153725,7 @@ var init_DocxZipper_gWkmvJfR_es = __esm(() => {
   DocxZipper_default = DocxZipper;
 });
 
-// ../../packages/superdoc/dist/chunks/vue-LcaAh-pz.es.js
+// ../../packages/superdoc/dist/chunks/vue-DMgTaOx9.es.js
 function makeMap(str) {
   const map$12 = /* @__PURE__ */ Object.create(null);
   for (const key of str.split(","))
@@ -159032,7 +159776,7 @@ var EMPTY_OBJ, EMPTY_ARR, NOOP = () => {}, NO = () => false, isOn = (key) => key
   };
   return app;
 };
-var init_vue_LcaAh_pz_es = __esm(() => {
+var init_vue_DMgTaOx9_es = __esm(() => {
   init_jszip_ChlR43oI_es();
   init_dist$1();
   init_dist4();
@@ -159887,18 +160631,18 @@ var init_vue_LcaAh_pz_es = __esm(() => {
     initDev();
 });
 
-// ../../packages/superdoc/dist/chunks/_plugin-vue_export-helper-DBsdbQXw.es.js
+// ../../packages/superdoc/dist/chunks/_plugin-vue_export-helper-HmhZBO0u.es.js
 var __plugin_vue_export_helper_default = (sfc, props) => {
   const target = sfc.__vccOpts || sfc;
   for (const [key, val] of props)
     target[key] = val;
   return target;
 };
-var init__plugin_vue_export_helper_DBsdbQXw_es = () => {};
+var init__plugin_vue_export_helper_HmhZBO0u_es = () => {};
 
-// ../../packages/superdoc/dist/chunks/eventemitter3-C8I7im8Y.es.js
+// ../../packages/superdoc/dist/chunks/eventemitter3-DGBTyUUP.es.js
 var import_eventemitter3, eventemitter3_default;
-var init_eventemitter3_C8I7im8Y_es = __esm(() => {
+var init_eventemitter3_DGBTyUUP_es = __esm(() => {
   init_rolldown_runtime_B2q5OVn9_es();
   import_eventemitter3 = /* @__PURE__ */ __toESM2((/* @__PURE__ */ __commonJSMin((exports, module) => {
     var has = Object.prototype.hasOwnProperty, prefix = "~";
@@ -160068,8 +160812,8 @@ var init_eventemitter3_C8I7im8Y_es = __esm(() => {
   eventemitter3_default = import_eventemitter3.default;
 });
 
-// ../../packages/superdoc/dist/chunks/blank-docx-DFCuImiw.es.js
-var init_blank_docx_DFCuImiw_es = () => {};
+// ../../packages/superdoc/dist/chunks/blank-docx-sI869qur.es.js
+var init_blank_docx_sI869qur_es = () => {};
 
 // ../../packages/superdoc/dist/chunks/unified-Df6iltvW.es.js
 var exports_unified_Df6iltvW_es = {};
@@ -160080,9 +160824,9 @@ var init_unified_Df6iltvW_es = __esm(() => {
   init_unified_BRHLwnjP_es();
 });
 
-// ../../packages/superdoc/dist/chunks/rehype-parse-DBGL9UkS.es.js
-var exports_rehype_parse_DBGL9UkS_es = {};
-__export(exports_rehype_parse_DBGL9UkS_es, {
+// ../../packages/superdoc/dist/chunks/rehype-parse-BLZiqvrL.es.js
+var exports_rehype_parse_BLZiqvrL_es = {};
+__export(exports_rehype_parse_BLZiqvrL_es, {
   default: () => rehypeParse
 });
 function merge2(definitions, space) {
@@ -166031,7 +166775,7 @@ var Schema2 = class {
     }
   }
 }, TABLE_VOID_ELEMENTS, errors, base3 = "https://html.spec.whatwg.org/multipage/parsing.html#parse-error-", dashToCamelRe, formatCRe, formatXRe, fatalities, emptyOptions3;
-var init_rehype_parse_DBGL9UkS_es = __esm(() => {
+var init_rehype_parse_BLZiqvrL_es = __esm(() => {
   init_rolldown_runtime_B2q5OVn9_es();
   init_default_Cj_AMFZ9_es();
   init_lib_HnbxUP96_es();
@@ -168776,9 +169520,9 @@ var init_rehype_parse_DBGL9UkS_es = __esm(() => {
   emptyOptions3 = {};
 });
 
-// ../../packages/superdoc/dist/chunks/rehype-remark-CBHTrfcB.es.js
-var exports_rehype_remark_CBHTrfcB_es = {};
-__export(exports_rehype_remark_CBHTrfcB_es, {
+// ../../packages/superdoc/dist/chunks/rehype-remark-pZi116RJ.es.js
+var exports_rehype_remark_pZi116RJ_es = {};
+__export(exports_rehype_remark_pZi116RJ_es, {
   default: () => rehypeRemark
 });
 function anyFactory2(tests) {
@@ -170398,7 +171142,7 @@ var env, deserializer = ($2, _) => {
     if (is(parent.children[index2], index2, parent))
       return parent.children[index2];
 }, searchLineFeeds, searchTabOrSpaces, br$1, cell, p$1, row, notRendered, blockOrCaption, prefix = "language-", defaultChecked = "[x]", defaultUnchecked = "[ ]", own$12, list$1, basic, meta, defaultQuotes, nodeHandlers, handlers2, own6, emptyOptions4, defaults;
-var init_rehype_remark_CBHTrfcB_es = __esm(() => {
+var init_rehype_remark_pZi116RJ_es = __esm(() => {
   init_lib_DAB30bX1_es();
   env = typeof self === "object" ? self : globalThis;
   ({ toString: toString$1 } = {});
@@ -170774,12 +171518,12 @@ var init_rehype_remark_CBHTrfcB_es = __esm(() => {
   defaults = { document: true };
 });
 
-// ../../packages/superdoc/dist/chunks/remark-stringify-CEWHbwty.es.js
-var exports_remark_stringify_CEWHbwty_es = {};
-__export(exports_remark_stringify_CEWHbwty_es, {
+// ../../packages/superdoc/dist/chunks/remark-stringify-WeOdhmLF.es.js
+var exports_remark_stringify_WeOdhmLF_es = {};
+__export(exports_remark_stringify_WeOdhmLF_es, {
   default: () => remarkStringify
 });
-var init_remark_stringify_CEWHbwty_es = __esm(() => {
+var init_remark_stringify_WeOdhmLF_es = __esm(() => {
   init_remark_stringify_D8vxv_XI_es();
 });
 
@@ -170792,7 +171536,7 @@ var init_remark_gfm_CjV8kaUy_es = __esm(() => {
   init_remark_gfm_z_sDF4ss_es();
 });
 
-// ../../packages/superdoc/dist/chunks/src-6kViff8n.es.js
+// ../../packages/superdoc/dist/chunks/src-DWC5tAy5.es.js
 function deleteProps(obj, propOrProps) {
   const props = typeof propOrProps === "string" ? [propOrProps] : propOrProps;
   const removeNested = (target, pathParts, index2 = 0) => {
@@ -177121,7 +177865,7 @@ function getOppositePlacement(placement2) {
 }
 function getOppositeVariationPlacement(placement2) {
   return placement2.replace(/start|end/g, function(matched) {
-    return hash[matched];
+    return hash2[matched];
   });
 }
 function getWindowScroll(node3) {
@@ -234324,7 +235068,7 @@ var Node$13 = class Node$14 {
 }, TextTransform, Placeholder, bottom = "bottom", right = "right", left = "left", auto = "auto", basePlacements, start = "start", clippingParents = "clippingParents", viewport = "viewport", popper = "popper", reference = "reference", variationPlacements, placements, modifierPhases, applyStyles_default, max4, min4, round, toPaddingObject = function toPaddingObject$1(padding, state) {
   padding = typeof padding === "function" ? padding(Object.assign({}, state.rects, { placement: state.placement })) : padding;
   return mergePaddingObject(typeof padding !== "number" ? padding : expandToHashMap(padding, basePlacements));
-}, arrow_default, unsetSides, computeStyles_default, passive, eventListeners_default, hash$1, hash, flip_default, hide_default, offset_default, popperOffsets_default, preventOverflow_default, DEFAULT_OPTIONS, createPopper, BOX_CLASS = "tippy-box", CONTENT_CLASS = "tippy-content", BACKDROP_CLASS = "tippy-backdrop", ARROW_CLASS = "tippy-arrow", SVG_ARROW_CLASS = "tippy-svg-arrow", TOUCH_OPTIONS, TIPPY_DEFAULT_APPEND_TO = function TIPPY_DEFAULT_APPEND_TO$1() {
+}, arrow_default, unsetSides, computeStyles_default, passive, eventListeners_default, hash$1, hash2, flip_default, hide_default, offset_default, popperOffsets_default, preventOverflow_default, DEFAULT_OPTIONS, createPopper, BOX_CLASS = "tippy-box", CONTENT_CLASS = "tippy-content", BACKDROP_CLASS = "tippy-backdrop", ARROW_CLASS = "tippy-arrow", SVG_ARROW_CLASS = "tippy-svg-arrow", TOUCH_OPTIONS, TIPPY_DEFAULT_APPEND_TO = function TIPPY_DEFAULT_APPEND_TO$1() {
   return document.body;
 }, currentInput, lastMouseMoveTime = 0, isIE11, visitedMessages, pluginProps, defaultProps, defaultKeys, setDefaultProps = function setDefaultProps$1(partialProps) {
   if (process$1.env.NODE_ENV !== "production")
@@ -240549,7 +241293,7 @@ var Node$13 = class Node$14 {
     });
     return Object.fromEntries(markEntries);
   }
-}, EditorError, InvalidStateError, NoSourcePathError, FileSystemNotAvailableError, DocumentLoadError, Commands, handleEnter = (editor) => {
+}, Commands, handleEnter = (editor) => {
   const { view } = editor;
   view?.dispatch?.(closeHistory(view?.state?.tr));
   return editor.commands.first(({ commands: commands$1 }) => [
@@ -250552,20 +251296,22 @@ var Node$13 = class Node$14 {
     return;
   console.log(...args$1);
 }, HEADER_FOOTER_INIT_BUDGET_MS = 200, MAX_ZOOM_WARNING_THRESHOLD = 10, MAX_SELECTION_RECTS_PER_USER = 100, SEMANTIC_RESIZE_DEBOUNCE_MS = 120, MIN_SEMANTIC_CONTENT_WIDTH_PX = 1, GLOBAL_PERFORMANCE, PresentationEditor, ICONS, TEXTS, tableActionsOptions;
-var init_src_6kViff8n_es = __esm(() => {
+var init_src_DWC5tAy5_es = __esm(() => {
   init_rolldown_runtime_B2q5OVn9_es();
-  init_SuperConverter_DPILugtg_es();
+  init_SuperConverter_CXcZg9Os_es();
   init_jszip_ChlR43oI_es();
   init_uuid_qzgm05fK_es();
   init_constants_Qqwopz80_es();
   init_unified_BRHLwnjP_es();
   init_remark_gfm_z_sDF4ss_es();
   init_remark_stringify_D8vxv_XI_es();
-  init_DocxZipper_gWkmvJfR_es();
-  init_vue_LcaAh_pz_es();
-  init__plugin_vue_export_helper_DBsdbQXw_es();
-  init_eventemitter3_C8I7im8Y_es();
-  init_blank_docx_DFCuImiw_es();
+  init_DocxZipper_DvDGw347_es();
+  init_dist_Cwvmda4Q_es();
+  init_vue_DMgTaOx9_es();
+  init__plugin_vue_export_helper_HmhZBO0u_es();
+  init_eventemitter3_DGBTyUUP_es();
+  init_errors_CtyzHiH4_es();
+  init_blank_docx_sI869qur_es();
   init_yjs();
   init_yjs();
   CSS_DIMENSION_REGEX = /[\d-.]+(\w+)$/;
@@ -264722,7 +265468,7 @@ ${err.toString()}`);
           }
           return result$1;
         }
-        function concat() {
+        function concat2() {
           var length$12 = arguments.length;
           if (!length$12)
             return [];
@@ -266443,7 +267189,7 @@ function print() { __p += __j.call(arguments, '') }
         lodash.chain = chain;
         lodash.chunk = chunk2;
         lodash.compact = compact2;
-        lodash.concat = concat;
+        lodash.concat = concat2;
         lodash.cond = cond;
         lodash.conforms = conforms;
         lodash.constant = constant;
@@ -267521,7 +268267,7 @@ function print() { __p += __j.call(arguments, '') }
     bottom: "top",
     top: "bottom"
   };
-  hash = {
+  hash2 = {
     start: "end",
     end: "start"
   };
@@ -275600,37 +276346,6 @@ function print() { __p += __j.call(arguments, '') }
       }
     }
   };
-  EditorError = class extends Error {
-    constructor(message) {
-      super(message);
-      this.name = "EditorError";
-    }
-  };
-  InvalidStateError = class extends EditorError {
-    constructor(message) {
-      super(message);
-      this.name = "InvalidStateError";
-    }
-  };
-  NoSourcePathError = class extends EditorError {
-    constructor(message) {
-      super(message);
-      this.name = "NoSourcePathError";
-    }
-  };
-  FileSystemNotAvailableError = class extends EditorError {
-    constructor(message) {
-      super(message);
-      this.name = "FileSystemNotAvailableError";
-    }
-  };
-  DocumentLoadError = class extends EditorError {
-    constructor(message, cause) {
-      super(message);
-      this.name = "DocumentLoadError";
-      this.cause = cause;
-    }
-  };
   Commands = Extension.create({
     name: "commands",
     addCommands() {
@@ -277502,16 +278217,17 @@ function print() { __p += __j.call(arguments, '') }
           markdown: options?.markdown,
           jsonOverride: options?.json ?? null
         };
+        const loadOptions = options?.password ? { password: options.password } : undefined;
         if (typeof source === "string")
           if (typeof process$12 !== "undefined" && process$12.versions?.node) {
             const buffer4 = (init_empty(), __toCommonJS(empty_exports)).readFileSync(source);
-            const [docx, _media, mediaFiles, fonts] = await Editor2.loadXmlData(buffer4, true);
+            const [docx, _media, mediaFiles, fonts, decryptedData] = await Editor2.loadXmlData(buffer4, true, loadOptions);
             resolvedOptions.content = docx;
             resolvedOptions.mediaFiles = mediaFiles;
             resolvedOptions.fonts = fonts;
-            resolvedOptions.fileSource = buffer4;
+            resolvedOptions.fileSource = decryptedData ?? buffer4;
             resolvedOptions.isNewFile = explicitIsNewFile ?? false;
-            this.#sourcePath = source;
+            this.#sourcePath = decryptedData ? null : source;
           } else {
             const response = await fetch(source);
             if (!response.ok) {
@@ -277519,11 +278235,11 @@ function print() { __p += __j.call(arguments, '') }
               throw new Error(`Fetch failed: ${response.status} ${response.statusText}`);
             }
             const blob = await response.blob();
-            const [docx, _media, mediaFiles, fonts] = await Editor2.loadXmlData(blob);
+            const [docx, _media, mediaFiles, fonts, decryptedData] = await Editor2.loadXmlData(blob, false, loadOptions);
             resolvedOptions.content = docx;
             resolvedOptions.mediaFiles = mediaFiles;
             resolvedOptions.fonts = fonts;
-            resolvedOptions.fileSource = blob;
+            resolvedOptions.fileSource = decryptedData ?? blob;
             resolvedOptions.isNewFile = explicitIsNewFile ?? false;
             this.#sourcePath = source.split("/").pop() || null;
           }
@@ -277533,19 +278249,19 @@ function print() { __p += __j.call(arguments, '') }
           const isArrayBuffer = source instanceof ArrayBuffer;
           const hasArrayBuffer = typeof source === "object" && "buffer" in source && source.buffer instanceof ArrayBuffer;
           if (isNodeBuffer || isBlob || isArrayBuffer || hasArrayBuffer) {
-            const [docx, _media, mediaFiles, fonts] = await Editor2.loadXmlData(source, isNodeBuffer);
+            const [docx, _media, mediaFiles, fonts, decryptedData] = await Editor2.loadXmlData(source, isNodeBuffer, loadOptions);
             resolvedOptions.content = docx;
             resolvedOptions.mediaFiles = mediaFiles;
             resolvedOptions.fonts = fonts;
-            resolvedOptions.fileSource = source;
+            resolvedOptions.fileSource = decryptedData ?? source;
             resolvedOptions.isNewFile = explicitIsNewFile ?? false;
             this.#sourcePath = null;
           } else {
-            const [docx, _media, mediaFiles, fonts] = await Editor2.loadXmlData(source, false);
+            const [docx, _media, mediaFiles, fonts, decryptedData] = await Editor2.loadXmlData(source, false, loadOptions);
             resolvedOptions.content = docx;
             resolvedOptions.mediaFiles = mediaFiles;
             resolvedOptions.fonts = fonts;
-            resolvedOptions.fileSource = source;
+            resolvedOptions.fileSource = decryptedData ?? source;
             resolvedOptions.isNewFile = explicitIsNewFile ?? false;
             this.#sourcePath = null;
           }
@@ -277606,6 +278322,10 @@ function print() { __p += __j.call(arguments, '') }
           this.#registerCopyHandler();
         }
       } catch (error3) {
+        if (error3 instanceof DocxEncryptionError) {
+          console.debug("[SuperDoc] Document load error:", error3.message);
+          throw error3;
+        }
         const err = error3 instanceof Error ? error3 : new Error(String(error3));
         console.debug("[SuperDoc] Document load error:", err.message);
         throw new DocumentLoadError(`Failed to load document: ${err.message}`, err);
@@ -278150,15 +278870,16 @@ function print() { __p += __j.call(arguments, '') }
         return !canRender && !isFontImported;
       });
     }
-    static async loadXmlData(fileSource, isNode$1 = false) {
+    static async loadXmlData(fileSource, isNode$1 = false, options) {
       if (!fileSource)
         return;
       const zipper = new DocxZipper_default;
       return [
-        await zipper.getDocxData(fileSource, isNode$1),
+        await zipper.getDocxData(fileSource, isNode$1, { password: options?.password }),
         zipper.media,
         zipper.mediaFiles,
-        zipper.fonts
+        zipper.fonts,
+        zipper.decryptedFileData
       ];
     }
     static getDocumentVersion(doc$12) {
@@ -278546,9 +279267,9 @@ function print() { __p += __j.call(arguments, '') }
       try {
         const [{ unified: unified$1 }, { default: rehypeParse2 }, { default: rehypeRemark2 }, { default: remarkStringify$1 }, { default: remarkGfm$1 }] = await Promise.all([
           Promise.resolve().then(() => (init_unified_Df6iltvW_es(), exports_unified_Df6iltvW_es)),
-          Promise.resolve().then(() => (init_rehype_parse_DBGL9UkS_es(), exports_rehype_parse_DBGL9UkS_es)),
-          Promise.resolve().then(() => (init_rehype_remark_CBHTrfcB_es(), exports_rehype_remark_CBHTrfcB_es)),
-          Promise.resolve().then(() => (init_remark_stringify_CEWHbwty_es(), exports_remark_stringify_CEWHbwty_es)),
+          Promise.resolve().then(() => (init_rehype_parse_BLZiqvrL_es(), exports_rehype_parse_BLZiqvrL_es)),
+          Promise.resolve().then(() => (init_rehype_remark_pZi116RJ_es(), exports_rehype_remark_pZi116RJ_es)),
+          Promise.resolve().then(() => (init_remark_stringify_WeOdhmLF_es(), exports_remark_stringify_WeOdhmLF_es)),
           Promise.resolve().then(() => (init_remark_gfm_CjV8kaUy_es(), exports_remark_gfm_CjV8kaUy_es))
         ]);
         const html3 = this.getHTML();
@@ -278762,7 +279483,7 @@ function print() { __p += __j.call(arguments, '') }
         isHeadless: !(config2?.element != null || config2?.selector != null),
         ...config2
       };
-      const { html: html3, markdown, json, isCommentsEnabled, suppressDefaultDocxStyles, documentMode, content: content3, mediaFiles, fonts, isNewFile, ...editorConfig } = resolvedConfig;
+      const { html: html3, markdown, json, isCommentsEnabled, suppressDefaultDocxStyles, documentMode, content: content3, mediaFiles, fonts, isNewFile, password, ...editorConfig } = resolvedConfig;
       const openOptions = {
         mode: resolvedConfig.mode,
         html: html3,
@@ -278774,7 +279495,8 @@ function print() { __p += __j.call(arguments, '') }
         content: content3,
         mediaFiles,
         fonts,
-        isNewFile
+        isNewFile,
+        password
       };
       const editor = new Editor2({
         ...editorConfig,
@@ -278914,11 +279636,11 @@ function print() { __p += __j.call(arguments, '') }
         return;
       return (syncPlugin?.getState(this.state)).doc;
     }
-    async replaceFile(newFile) {
+    async replaceFile(newFile, options) {
       this.setOptions({ annotations: true });
-      const [docx, media2, mediaFiles, fonts] = await Editor2.loadXmlData(newFile);
+      const [docx, media2, mediaFiles, fonts, decryptedData] = await Editor2.loadXmlData(newFile, false, options);
       this.setOptions({
-        fileSource: newFile,
+        fileSource: decryptedData ?? newFile,
         content: docx,
         media: media2,
         mediaFiles,
@@ -283864,9 +284586,9 @@ function print() { __p += __j.call(arguments, '') }
   ];
 });
 
-// ../../packages/superdoc/dist/chunks/zipper-DqXT7uTa.es.js
+// ../../packages/superdoc/dist/chunks/zipper-YmNpPIyc.es.js
 var import_jszip_min2;
-var init_zipper_DqXT7uTa_es = __esm(() => {
+var init_zipper_YmNpPIyc_es = __esm(() => {
   init_rolldown_runtime_B2q5OVn9_es();
   init_jszip_ChlR43oI_es();
   import_jszip_min2 = /* @__PURE__ */ __toESM2(require_jszip_min(), 1);
@@ -283874,16 +284596,18 @@ var init_zipper_DqXT7uTa_es = __esm(() => {
 
 // ../../packages/superdoc/dist/super-editor.es.js
 var init_super_editor_es = __esm(() => {
-  init_src_6kViff8n_es();
-  init_SuperConverter_DPILugtg_es();
+  init_src_DWC5tAy5_es();
+  init_SuperConverter_CXcZg9Os_es();
   init_jszip_ChlR43oI_es();
   init_xml_js_40FWvL78_es();
   init_constants_Qqwopz80_es();
   init_unified_BRHLwnjP_es();
-  init_DocxZipper_gWkmvJfR_es();
-  init_vue_LcaAh_pz_es();
-  init_eventemitter3_C8I7im8Y_es();
-  init_zipper_DqXT7uTa_es();
+  init_DocxZipper_DvDGw347_es();
+  init_dist_Cwvmda4Q_es();
+  init_vue_DMgTaOx9_es();
+  init_eventemitter3_DGBTyUUP_es();
+  init_errors_CtyzHiH4_es();
+  init_zipper_YmNpPIyc_es();
 });
 
 // ../../node_modules/.pnpm/happy-dom@20.4.0/node_modules/happy-dom/lib/PropertySymbol.js
@@ -284625,12 +285349,12 @@ class ResponseCacheFileSystem {
             }
           };
           const json = JSON.stringify(cacheableEntry, null, 3);
-          const hash2 = Crypto.createHash("md5").update(json).digest("hex");
-          if (!this.#hashes.has(hash2)) {
-            this.#hashes.add(hash2);
-            promises.push(FS.promises.writeFile(Path3.join(absoluteDirectory, `${hash2}.json`), json));
+          const hash3 = Crypto.createHash("md5").update(json).digest("hex");
+          if (!this.#hashes.has(hash3)) {
+            this.#hashes.add(hash3);
+            promises.push(FS.promises.writeFile(Path3.join(absoluteDirectory, `${hash3}.json`), json));
             if (cachedResponse2.response.body) {
-              promises.push(FS.promises.writeFile(Path3.join(absoluteDirectory, `${hash2}.data`), cachedResponse2.response.body));
+              promises.push(FS.promises.writeFile(Path3.join(absoluteDirectory, `${hash3}.data`), cachedResponse2.response.body));
             }
           }
         }
@@ -289397,11 +290121,11 @@ class SelectorItem {
         }
         return null;
       case "target":
-        const hash2 = element3[ownerDocument].location.hash;
-        if (!hash2) {
+        const hash3 = element3[ownerDocument].location.hash;
+        if (!hash3) {
           return null;
         }
-        return element3.isConnected && element3.id === hash2.slice(1) ? { priorityWeight: 10 } : null;
+        return element3.isConnected && element3.id === hash3.slice(1) ? { priorityWeight: 10 } : null;
       case "is":
         let priorityWeightForIs = 0;
         if (!pseudo.selectorItems) {
@@ -298704,14 +299428,14 @@ var init_Location = __esm(() => {
     get hash() {
       return this.#url.hash;
     }
-    set hash(hash2) {
+    set hash(hash3) {
       const history3 = this.#browserFrame?.[history2];
       if (!history3 || !this.#browserFrame) {
         return;
       }
       const url3 = new URL(this.#url.href);
       const oldHash = this.#url.hash;
-      url3.hash = hash2;
+      url3.hash = hash3;
       if (url3.hash !== oldHash) {
         history3.currentItem.popState = true;
         history3.push({
@@ -306558,14 +307282,14 @@ class HTMLHyperlinkElementUtility {
     }
     return url3.hash;
   }
-  setHash(hash2) {
+  setHash(hash3) {
     let url3;
     try {
       url3 = new URL(this.getHref());
     } catch (e) {
       return;
     }
-    url3.hash = hash2;
+    url3.hash = hash3;
     this.element.setAttribute("href", url3.href);
   }
 }
@@ -306594,8 +307318,8 @@ var init_HTMLAnchorElement = __esm(() => {
     get hash() {
       return this.#htmlHyperlinkElementUtility.getHash();
     }
-    set hash(hash2) {
-      this.#htmlHyperlinkElementUtility.setHash(hash2);
+    set hash(hash3) {
+      this.#htmlHyperlinkElementUtility.setHash(hash3);
     }
     get href() {
       return this.#htmlHyperlinkElementUtility.getHref();
@@ -306871,8 +307595,8 @@ var init_HTMLAreaElement = __esm(() => {
     get hash() {
       return this.#htmlHyperlinkElementUtility.getHash();
     }
-    set hash(hash2) {
-      this.#htmlHyperlinkElementUtility.setHash(hash2);
+    set hash(hash3) {
+      this.#htmlHyperlinkElementUtility.setHash(hash3);
     }
     get tabIndex() {
       const tabIndex = this.getAttribute("tabindex");
@@ -332137,6 +332861,9 @@ async function openDocument(doc4, io, options2 = {}) {
   } catch (error4) {
     commentBridge?.dispose();
     domEnv.dispose();
+    if (error4 instanceof DocxEncryptionError) {
+      throw new CliError(error4.code, error4.message, { source: meta2 });
+    }
     const message = error4 instanceof Error ? error4.message : String(error4);
     throw new CliError("DOCUMENT_OPEN_FAILED", "Failed to open document.", {
       message,
@@ -332224,6 +332951,7 @@ async function openCollaborativeDocument(doc4, io, profile, options2 = {}) {
       ydoc: runtime.ydoc,
       collaborationProvider: runtime.provider,
       isNewFile: shouldSeed,
+      editorOpenOptions: options2.editorOpenOptions,
       user: options2.user
     });
     let raceDetection;
@@ -333491,10 +334219,10 @@ function buildStableIdMappings(rawListResult) {
     if (!rawId)
       return entry;
     const signature = stableTrackChangeSignature(entry);
-    const hash2 = createHash3("sha1").update(signature).digest("hex").slice(0, 24);
-    const nextCount = (signatureCounts.get(hash2) ?? 0) + 1;
-    signatureCounts.set(hash2, nextCount);
-    const stableId = nextCount === 1 ? hash2 : `${hash2}-${nextCount}`;
+    const hash3 = createHash3("sha1").update(signature).digest("hex").slice(0, 24);
+    const nextCount = (signatureCounts.get(hash3) ?? 0) + 1;
+    signatureCounts.set(hash3, nextCount);
+    const stableId = nextCount === 1 ? hash3 : `${hash3}-${nextCount}`;
     stableToRawId.set(stableId, rawId);
     rawToStableId.set(rawId, stableId);
     const normalizedAddress = asTrackChangeAddress(entry.address);
@@ -335008,7 +335736,7 @@ function deriveOptionSpecs(operationId, params4) {
   }
   return specs;
 }
-var DOC_PARAM, SESSION_PARAM, OUT_PARAM, FORCE_PARAM, DRY_RUN_PARAM, CHANGE_MODE_PARAM, EXPECTED_REVISION_PARAM, USER_NAME_PARAM, USER_EMAIL_PARAM, AGENT_HIDDEN_PARAM_NAMES, OPERATION_CONSTRAINTS, PARAM_FLAG_OVERRIDES, DOC_FIND_SELECT_SCHEMA, PARAM_SCHEMA_OVERRIDES, PARAM_EXCLUSIONS, TEXT_TARGET_FLAT_PARAMS, TEXT_TARGET_FLAT_PARAMS_AGENT_HIDDEN, LIST_TARGET_FLAT_PARAMS, FORMAT_OPERATION_IDS, EXTRA_CLI_PARAMS, CLI_ONLY_METADATA, CLI_OPERATION_METADATA, OPTION_FLAG_ALIASES, CLI_OPERATION_OPTION_SPECS;
+var DOC_PARAM, SESSION_PARAM, OUT_PARAM, FORCE_PARAM, DRY_RUN_PARAM, CHANGE_MODE_PARAM, EXPECTED_REVISION_PARAM, USER_NAME_PARAM, USER_EMAIL_PARAM, PASSWORD_PARAM, AGENT_HIDDEN_PARAM_NAMES, OPERATION_CONSTRAINTS, PARAM_FLAG_OVERRIDES, DOC_FIND_SELECT_SCHEMA, PARAM_SCHEMA_OVERRIDES, PARAM_EXCLUSIONS, TEXT_TARGET_FLAT_PARAMS, TEXT_TARGET_FLAT_PARAMS_AGENT_HIDDEN, LIST_TARGET_FLAT_PARAMS, FORMAT_OPERATION_IDS, EXTRA_CLI_PARAMS, CLI_ONLY_METADATA, CLI_OPERATION_METADATA, OPTION_FLAG_ALIASES, CLI_OPERATION_OPTION_SPECS;
 var init_operation_params = __esm(() => {
   init_src();
   init_commands();
@@ -335067,6 +335795,13 @@ var init_operation_params = __esm(() => {
     flag: "user-email",
     type: "string"
   };
+  PASSWORD_PARAM = {
+    name: "password",
+    kind: "flag",
+    type: "string",
+    description: "Password for opening encrypted DOCX files.",
+    agentVisible: false
+  };
   AGENT_HIDDEN_PARAM_NAMES = new Set(["out", "in"]);
   OPERATION_CONSTRAINTS = {
     "doc.find": {
@@ -335626,7 +336361,8 @@ var init_operation_params = __esm(() => {
         { name: "onMissing", kind: "flag", flag: "on-missing", type: "string" },
         { name: "bootstrapSettlingMs", kind: "flag", flag: "bootstrap-settling-ms", type: "number" },
         USER_NAME_PARAM,
-        USER_EMAIL_PARAM
+        USER_EMAIL_PARAM,
+        PASSWORD_PARAM
       ],
       constraints: null
     },
@@ -336955,6 +337691,15 @@ var init_close = __esm(() => {
   init_context();
 });
 
+// src/lib/open-password.ts
+function resolvePassword(explicit, allowEnvFallback = true) {
+  if (explicit != null)
+    return explicit;
+  if (allowEnvFallback)
+    return process.env.SUPERDOC_DOC_PASSWORD ?? undefined;
+  return;
+}
+
 // src/commands/open.ts
 async function runOpen(tokens, context) {
   const { parsed, help } = parseOperationArgs("doc.open", tokens, {
@@ -336966,16 +337711,20 @@ async function runOpen(tokens, context) {
       command: "open",
       data: {
         usage: [
-          "superdoc open [doc] [--session <id>]",
+          "superdoc open [doc] [--session <id>] [--password <password>]",
           "superdoc open [doc] --content-override <content> --override-type <markdown|html|text>",
-          'superdoc open [doc] --collaboration-json "{...}" [--session <id>]'
+          'superdoc open [doc] --collaboration-json "{...}" [--session <id>]',
+          "",
+          "Encrypted documents: use --password or set SUPERDOC_DOC_PASSWORD env var."
         ]
       },
       pretty: [
         "Usage:",
-        "  superdoc open [doc] [--session <id>]",
+        "  superdoc open [doc] [--session <id>] [--password <password>]",
         "  superdoc open [doc] --content-override <content> --override-type <markdown|html|text>",
-        '  superdoc open [doc] --collaboration-json "{...}" [--session <id>]'
+        '  superdoc open [doc] --collaboration-json "{...}" [--session <id>]',
+        "",
+        "Encrypted documents: use --password or set SUPERDOC_DOC_PASSWORD env var."
       ].join(`
 `)
     };
@@ -336991,6 +337740,8 @@ async function runOpen(tokens, context) {
   const bootstrapSettlingMs = getNumberOption(parsed, "bootstrap-settling-ms");
   const userName = getStringOption(parsed, "user-name");
   const userEmail = getStringOption(parsed, "user-email");
+  const allowEnvFallback = context.executionMode !== "host";
+  const password = resolvePassword(getStringOption(parsed, "password"), allowEnvFallback);
   if (contentOverride != null && !overrideType) {
     throw new CliError("INVALID_ARGUMENT", "open: --content-override requires --override-type.");
   }
@@ -337046,6 +337797,9 @@ async function runOpen(tokens, context) {
       editorOpenOptions.plainText = contentOverride;
     }
   }
+  if (password != null) {
+    editorOpenOptions.password = password;
+  }
   return withContextLock(context.io, "open", async (paths) => {
     const existing = await readContextMetadata(paths);
     if (existing && existing.projectRoot !== getProjectRoot()) {
@@ -337061,7 +337815,7 @@ async function runOpen(tokens, context) {
         revision: existing.revision
       });
     }
-    const opened = collaboration ? await openCollaborativeDocument(doc4, context.io, collaboration, { user }) : await openDocument(doc4, context.io, { editorOpenOptions, user });
+    const opened = collaboration ? await openCollaborativeDocument(doc4, context.io, collaboration, { editorOpenOptions, user }) : await openDocument(doc4, context.io, { editorOpenOptions, user });
     const bootstrap = "bootstrap" in opened ? opened.bootstrap : undefined;
     let adoptedToHostPool = false;
     try {