@opengeni/artifact-tool 0.2.2

package/dist/document-docx-codec.js

@@ -0,0 +1,4765 @@
+import {
+  DOCUMENT_LOSS_PRESERVATION,
+  DOCX_MEDIA_TYPE,
+  DocumentFidelityError,
+  documentFidelityReport,
+  documentLossPreservationEnvelope
+} from "./chunk-RBGQADXA.js";
+import {
+  Document,
+  DocumentPageBreak,
+  DocumentParagraph,
+  DocumentTable,
+  DocumentTextRun
+} from "./chunk-66CT2ZRP.js";
+import {
+  UnsupportedArtifactFeatureError
+} from "./chunk-O24KTEGP.js";
+import {
+  inflateBoundedZipEntry,
+  parseBoundedZip
+} from "./chunk-72SYDU4O.js";
+import {
+  FileBlob
+} from "./chunk-4BSENMAE.js";
+import "./chunk-Q2FFHEY7.js";
+import "./chunk-VUNV25KB.js";
+
+// src/document-docx-packer.ts
+var DOCX_MIME_TYPE = "application/vnd.openxmlformats-officedocument.wordprocessingml.document";
+var DocxExportCompatibilityError = class extends Error {
+  name = "DocxExportCompatibilityError";
+  code = "incompatible_docx_runtime";
+};
+async function packDocxWithBoundedCompression(file, packer, overrides = []) {
+  if (typeof packer !== "object" && typeof packer !== "function" || packer === null) {
+    throw incompatibleRuntime();
+  }
+  const compiler = Reflect.get(packer, "compiler");
+  if (!compiler || typeof compiler.compile !== "function") throw incompatibleRuntime();
+  const archive = compiler.compile(file, void 0, overrides);
+  if (!archive || typeof archive.generateAsync !== "function" || typeof archive.forEach !== "function")
+    throw incompatibleRuntime();
+  archive.forEach((_path, entry) => {
+    entry.date = new Date(1980, 0, 1, 0, 0, 0, 0);
+  });
+  const bytes = await archive.generateAsync({
+    type: "uint8array",
+    mimeType: DOCX_MIME_TYPE,
+    compression: "STORE"
+  });
+  if (!(bytes instanceof Uint8Array) || bytes.byteLength === 0) throw incompatibleRuntime();
+  return bytes;
+}
+function incompatibleRuntime() {
+  return new DocxExportCompatibilityError(
+    "The pinned DOCX runtime no longer exposes the verified bounded-compression compiler adapter"
+  );
+}
+
+// src/document-docx-import.ts
+var DocxImportError = class extends Error {
+  constructor(code, message, partName) {
+    super(partName ? `${message} (${partName})` : message);
+    this.code = code;
+    this.partName = partName;
+  }
+  name = "DocxImportError";
+};
+var DEFAULT_LIMITS = {
+  maxCompressedBytes: 32 * 1024 * 1024,
+  maxEntries: 1024,
+  maxEntryCompressedBytes: 16 * 1024 * 1024,
+  maxEntryUncompressedBytes: 24 * 1024 * 1024,
+  maxTotalUncompressedBytes: 64 * 1024 * 1024,
+  maxCompressionRatio: 100,
+  maxXmlBytes: 16 * 1024 * 1024,
+  maxTotalXmlBytes: 32 * 1024 * 1024,
+  maxRetainedXmlCharacters: 16e6,
+  maxXmlNodes: 1e5,
+  maxXmlDepth: 128,
+  maxXmlAttributesPerElement: 256,
+  maxRelationshipsPerPart: 1e4,
+  maxTotalRelationships: 1e5,
+  maxBlocks: 1e5,
+  maxTextCharacters: 1e7,
+  maxSections: 4096,
+  maxProjectedStoryBlocks: 2e5,
+  maxProjectedStoryCharacters: 2e7,
+  maxStyles: 1e4,
+  maxStyleInheritanceDepth: 64,
+  maxNumberingDefinitions: 2e4,
+  maxComments: 1e4,
+  maxProjectedCommentWork: 1e6
+};
+var WORD_RELATIONSHIP_BASE = "http://schemas.openxmlformats.org/officeDocument/2006/relationships/";
+var PACKAGE_RELATIONSHIP_BASE = "http://schemas.openxmlformats.org/package/2006/relationships/metadata/";
+var WORDPROCESSINGML_NAMESPACE = "http://schemas.openxmlformats.org/wordprocessingml/2006/main";
+var CONTENT_TYPES_NAMESPACE = "http://schemas.openxmlformats.org/package/2006/content-types";
+var RELATIONSHIPS_NAMESPACE = "http://schemas.openxmlformats.org/package/2006/relationships";
+var COMMENTS_EXTENDED_NAMESPACE = "http://schemas.microsoft.com/office/word/2012/wordml";
+async function importDocx(input, options = {}) {
+  const limits = resolveLimits(options);
+  const bytes = await readInput(input, limits.maxCompressedBytes);
+  const entries = parseZipDirectory(bytes, limits);
+  const opaqueParts = validatePartNames(entries);
+  const entriesByName = new Map(
+    entries.filter((entry) => !entry.directory).map((entry) => [entry.name, entry])
+  );
+  const partNames = new Set(entriesByName.keys());
+  validatePackageParts(partNames);
+  const budget = {
+    limits,
+    xmlBytes: 0,
+    xmlRetainedCharacters: 0,
+    xmlNodes: 0,
+    blocks: 0,
+    textCharacters: 0,
+    nextBlockId: 1
+  };
+  const parsedParts = /* @__PURE__ */ new Set();
+  const readXml = async (partName) => {
+    const entry = entriesByName.get(partName);
+    if (!entry)
+      throw new DocxImportError("invalid_package", "Required DOCX part is missing", partName);
+    if (parsedParts.has(partName)) {
+      throw new DocxImportError(
+        "invalid_package",
+        "DOCX part was consumed more than once",
+        partName
+      );
+    }
+    parsedParts.add(partName);
+    const value = await inflateBoundedZipEntry(
+      bytes,
+      entry,
+      limits.maxEntryUncompressedBytes,
+      docxZipFailure
+    );
+    return parseXmlPart(value, partName, budget);
+  };
+  for (const partName of partNames) {
+    if (isSyntaxOnlyXmlPart(partName) || opaqueParts.has(partName) && partName.endsWith(".xml"))
+      await readXml(partName);
+  }
+  const contentTypes = await readXml("[Content_Types].xml");
+  const contentTypeByPart = validateContentTypes(contentTypes, partNames);
+  const opaqueContentTypes = [];
+  for (const partName of opaqueParts) {
+    const contentType = contentTypeByPart.get(partName);
+    if (!contentType || !isSafeOpaqueContentType(partName, contentType)) {
+      throw new DocxImportError(
+        "unsupported_feature",
+        `Opaque DOCX part has an unsupported content type: ${contentType ?? "missing"}`,
+        partName
+      );
+    }
+    opaqueContentTypes.push({ partName, contentType });
+  }
+  if (partNames.has("word/footnotes.xml"))
+    validateEmptyNotePart(await readXml("word/footnotes.xml"), "footnote", "word/footnotes.xml");
+  if (partNames.has("word/endnotes.xml"))
+    validateEmptyNotePart(await readXml("word/endnotes.xml"), "endnote", "word/endnotes.xml");
+  const settings = partNames.has("word/settings.xml") ? validateSettings(await readXml("word/settings.xml")) : { evenAndOddHeaders: false, trackRevisions: false };
+  let totalRelationships = 0;
+  const readRelationships = async (partName) => {
+    const parsed = parseRelationships(
+      await readXml(partName),
+      partName,
+      limits.maxRelationshipsPerPart
+    );
+    if (totalRelationships + parsed.length > limits.maxTotalRelationships) {
+      throw limitError("DOCX exceeds maxTotalRelationships", partName);
+    }
+    totalRelationships += parsed.length;
+    return parsed;
+  };
+  const rootRelationships = await readRelationships("_rels/.rels");
+  const officeDocuments = rootRelationships.filter(
+    (relationship) => relationship.type === `${WORD_RELATIONSHIP_BASE}officeDocument`
+  );
+  const officeDocument = officeDocuments[0];
+  if (officeDocuments.length !== 1 || !officeDocument || officeDocument.partName !== "word/document.xml") {
+    throw new DocxImportError(
+      "invalid_package",
+      "DOCX officeDocument must target word/document.xml",
+      "_rels/.rels"
+    );
+  }
+  const documentRelationships = partNames.has("word/_rels/document.xml.rels") ? await readRelationships("word/_rels/document.xml.rels") : [];
+  const auxiliaryRelationships = [];
+  for (const partName of partNames) {
+    if (!partName.endsWith(".rels") || partName === "_rels/.rels" || partName === "word/_rels/document.xml.rels")
+      continue;
+    for (const relationship of await readRelationships(partName))
+      auxiliaryRelationships.push(relationship);
+  }
+  const allRelationships = [
+    ...rootRelationships,
+    ...documentRelationships,
+    ...auxiliaryRelationships
+  ];
+  const opaqueRelationships = validateRelationships(allRelationships, opaqueParts);
+  for (const relationship of allRelationships) {
+    if (!partNames.has(relationship.partName)) {
+      throw new DocxImportError(
+        "invalid_package",
+        "Relationship targets a missing package part",
+        relationship.partName
+      );
+    }
+  }
+  validateRelationshipCoverage(partNames, allRelationships);
+  const relationshipById = new Map(
+    documentRelationships.map((relationship) => [relationship.id, relationship])
+  );
+  const styles = partNames.has("word/styles.xml") ? parseStyles(await readXml("word/styles.xml"), limits) : [];
+  const lists = partNames.has("word/numbering.xml") ? parseNumbering(await readXml("word/numbering.xml"), limits) : [];
+  const trackedChanges = [];
+  const mainContext = { budget, trackedChanges, idPrefix: "body" };
+  const main = parseMainDocument(await readXml("word/document.xml"), mainContext, relationshipById);
+  resolveSectionStoryInheritance(main.sections);
+  const headers = [];
+  const footers = [];
+  const parsedStoryParts = /* @__PURE__ */ new Set();
+  for (const relationship of documentRelationships) {
+    const kind = relationship.type === `${WORD_RELATIONSHIP_BASE}header` ? "header" : relationship.type === `${WORD_RELATIONSHIP_BASE}footer` ? "footer" : void 0;
+    if (!kind) continue;
+    if (parsedStoryParts.has(relationship.partName)) continue;
+    parsedStoryParts.add(relationship.partName);
+    const root = await readXml(relationship.partName);
+    requireLocalName(root, kind === "header" ? "hdr" : "ftr", relationship.partName);
+    requireWordNamespace(root, relationship.partName);
+    const context = {
+      budget,
+      trackedChanges,
+      idPrefix: `${kind}:${relationship.partName}`
+    };
+    const blocks = parseBlockContainer(root, context);
+    (kind === "header" ? headers : footers).push({ kind, partName: relationship.partName, blocks });
+  }
+  validateProjectedStories(
+    main.sections,
+    headers,
+    footers,
+    limits.maxProjectedStoryBlocks,
+    limits.maxProjectedStoryCharacters
+  );
+  const commentsExtended = partNames.has("word/commentsExtended.xml") ? parseCommentsExtended(await readXml("word/commentsExtended.xml"), limits.maxComments) : /* @__PURE__ */ new Map();
+  const comments = partNames.has("word/comments.xml") ? parseComments(
+    await readXml("word/comments.xml"),
+    { budget, trackedChanges, idPrefix: "comment" },
+    commentsExtended,
+    limits.maxComments
+  ) : [];
+  if (commentsExtended.size > 0 && comments.length === 0) {
+    throw new DocxImportError(
+      "invalid_package",
+      "commentsExtended.xml exists without comments.xml",
+      "word/commentsExtended.xml"
+    );
+  }
+  validateCommentReferences(main.blocks, headers, footers, comments);
+  const rootCommentCount = comments.reduce(
+    (count, comment) => count + Number(comment.parentId === void 0),
+    0
+  );
+  if (rootCommentCount > 0 && rootCommentCount * (budget.blocks + comments.length) > limits.maxProjectedCommentWork) {
+    throw limitError("DOCX exceeds maxProjectedCommentWork", "word/comments.xml");
+  }
+  return {
+    format: "docx",
+    schemaVersion: 1,
+    evenAndOddHeaders: settings.evenAndOddHeaders,
+    trackRevisions: settings.trackRevisions,
+    blocks: main.blocks,
+    sections: main.sections,
+    styles,
+    lists,
+    headers,
+    footers,
+    comments,
+    trackedChanges,
+    opaqueContent: {
+      parts: [...opaqueParts].sort(compareStrings),
+      relationships: opaqueRelationships.map(({ sourcePart, type, partName }) => ({ sourcePart, type, targetPart: partName })).sort(compareOpaqueRelationships),
+      contentTypes: opaqueContentTypes.sort(compareOpaqueContentTypes)
+    }
+  };
+}
+function resolveLimits(options) {
+  if (options === null || typeof options !== "object" || Array.isArray(options) || Object.getPrototypeOf(options) !== Object.prototype || Object.getOwnPropertySymbols(options).length > 0)
+    throw new DocxImportError("invalid_input", "DOCX import limits must be a plain data object");
+  for (const [name, descriptor] of Object.entries(Object.getOwnPropertyDescriptors(options))) {
+    if (!("value" in descriptor) || !descriptor.enumerable) {
+      throw new DocxImportError(
+        "invalid_input",
+        "DOCX import limits must contain only enumerable data properties"
+      );
+    }
+    if (!Object.prototype.hasOwnProperty.call(DEFAULT_LIMITS, name)) {
+      throw new DocxImportError("invalid_input", `Unknown DOCX import limit: ${name}`);
+    }
+  }
+  const limits = { ...DEFAULT_LIMITS, ...options };
+  for (const [name, value] of Object.entries(limits)) {
+    if (!Number.isFinite(value) || value <= 0 || name !== "maxCompressionRatio" && !Number.isInteger(value)) {
+      throw new DocxImportError("invalid_input", `Invalid DOCX import limit: ${name}`);
+    }
+  }
+  for (const [name, cap] of Object.entries(DEFAULT_LIMITS)) {
+    if (limits[name] > cap)
+      throw new DocxImportError(
+        "invalid_input",
+        `${name} cannot exceed the hard safety cap of ${cap}`
+      );
+  }
+  return limits;
+}
+async function readInput(input, maxBytes) {
+  if (input instanceof ArrayBuffer) {
+    if (input.byteLength > maxBytes) throw limitError("Compressed DOCX exceeds maxCompressedBytes");
+    return new Uint8Array(input);
+  }
+  if (typeof Blob !== "undefined" && input instanceof Blob) {
+    if (input.size > maxBytes) throw limitError("Compressed DOCX exceeds maxCompressedBytes");
+    return new Uint8Array(await input.arrayBuffer());
+  }
+  throw new DocxImportError("invalid_input", "DOCX input must be a Blob or ArrayBuffer");
+}
+function parseZipDirectory(bytes, limits) {
+  return parseBoundedZip(
+    bytes,
+    {
+      entries: limits.maxEntries,
+      compressedEntryBytes: limits.maxEntryCompressedBytes,
+      expandedEntryBytes: limits.maxEntryUncompressedBytes,
+      expandedBytes: limits.maxTotalUncompressedBytes,
+      compressionRatio: limits.maxCompressionRatio
+    },
+    docxZipFailure
+  );
+}
+function docxZipFailure(kind, message, partName) {
+  const code = kind === "limit" ? "limit_exceeded" : kind === "invalid" ? "invalid_zip" : kind === "platform" ? "unsupported_platform" : "unsupported_feature";
+  throw new DocxImportError(code, message, partName);
+}
+function validatePartNames(parts) {
+  const opaqueParts = /* @__PURE__ */ new Set();
+  for (const entry of parts) {
+    if (entry.directory) continue;
+    const name = entry.name;
+    const supported = name === "[Content_Types].xml" || name === "_rels/.rels" || /^docProps\/(?:core|app|custom)\.xml$/.test(name) || name === "word/document.xml" || name === "word/styles.xml" || name === "word/numbering.xml" || name === "word/comments.xml" || name === "word/commentsExtended.xml" || name === "word/footnotes.xml" || name === "word/endnotes.xml" || name === "word/settings.xml" || name === "word/webSettings.xml" || name === "word/fontTable.xml" || /^word\/theme\/theme\d+\.xml$/.test(name) || /^word\/(?:header|footer)\d+\.xml$/.test(name) || /^word\/_rels\/(?:document|header\d+|footer\d+|footnotes|endnotes|comments|fontTable)\.xml\.rels$/.test(
+      name
+    );
+    if (supported) {
+      if (isSyntaxOnlyXmlPart(name)) opaqueParts.add(name);
+      continue;
+    }
+    if (isSafeOpaquePartName(name)) {
+      opaqueParts.add(name);
+      continue;
+    }
+    const active = /(?:^|\/)(?:vbaProject|macros?|activeX|embeddings|oleObject|customUI|webExtensions?|signatures?|drm|encryptedPackage)(?:\/|\.|$)/i.test(
+      name
+    );
+    const media = /(?:^|\/)media(?:\/|$)|\.(?:png|jpe?g|gif|webp|svg|emf|wmf|tiff?|bmp|bin)$/i.test(
+      name
+    );
+    throw new DocxImportError(
+      "unsupported_feature",
+      active ? "Active, executable, embedded, encrypted, or signed DOCX content is unsupported" : media ? "DOCX media is not represented by the editable document model" : "DOCX part is neither represented nor in the inert opaque-part allowlist",
+      name
+    );
+  }
+  return opaqueParts;
+}
+function isSafeOpaquePartName(partName) {
+  return /^customXml\/item\d+\.xml$/.test(partName) || /^customXml\/itemProps\d+\.xml$/.test(partName) || /^customXml\/_rels\/item\d+\.xml\.rels$/.test(partName) || partName === "word/glossary/document.xml" || partName === "word/glossary/_rels/document.xml.rels";
+}
+function validatePackageParts(parts) {
+  for (const required of ["[Content_Types].xml", "_rels/.rels", "word/document.xml"]) {
+    if (!parts.has(required))
+      throw new DocxImportError("invalid_package", "Required DOCX part is missing", required);
+  }
+}
+function isSyntaxOnlyXmlPart(partName) {
+  return /^docProps\/(?:core|app|custom)\.xml$/.test(partName) || partName === "word/webSettings.xml" || partName === "word/fontTable.xml" || /^word\/theme\/theme\d+\.xml$/.test(partName);
+}
+function parseXmlPart(bytes, partName, budget) {
+  if (bytes.byteLength > budget.limits.maxXmlBytes)
+    throw limitError("XML part exceeds maxXmlBytes", partName);
+  budget.xmlBytes += bytes.byteLength;
+  if (budget.xmlBytes > budget.limits.maxTotalXmlBytes)
+    throw limitError("DOCX exceeds maxTotalXmlBytes", partName);
+  const xml = decodeUtf8(bytes, "XML", partName);
+  if (/<!\s*(?:DOCTYPE|ENTITY)\b/i.test(xml)) {
+    throw new DocxImportError(
+      "invalid_xml",
+      "DOCTYPE and entity declarations are forbidden",
+      partName
+    );
+  }
+  const parsed = parseXml(
+    xml,
+    partName,
+    budget.limits.maxXmlDepth,
+    budget.limits.maxXmlNodes - budget.xmlNodes,
+    budget.limits.maxRetainedXmlCharacters - budget.xmlRetainedCharacters,
+    budget.limits.maxXmlAttributesPerElement,
+    partName.endsWith(".rels") ? budget.limits.maxRelationshipsPerPart : void 0
+  );
+  validateNamespaceWellFormedness(parsed.root, partName);
+  budget.xmlNodes += parsed.nodeCount;
+  if (budget.xmlNodes > budget.limits.maxXmlNodes)
+    throw limitError("DOCX exceeds maxXmlNodes", partName);
+  budget.xmlRetainedCharacters += parsed.retainedCharacters;
+  if (budget.xmlRetainedCharacters > budget.limits.maxRetainedXmlCharacters) {
+    throw limitError("DOCX exceeds maxRetainedXmlCharacters", partName);
+  }
+  return parsed.root;
+}
+function parseXml(xml, partName, maxDepth, remainingNodes, remainingRetainedCharacters, maxAttributesPerElement, maxRootElementChildren) {
+  const stack = [];
+  let root;
+  let cursor = 0;
+  let nodeCount = 0;
+  let retainedCharacters = 0;
+  let sawXmlDeclaration = false;
+  let rootElementChildren = 0;
+  const addNode = (node) => {
+    nodeCount += 1;
+    if (nodeCount > remainingNodes) throw limitError("DOCX exceeds maxXmlNodes", partName);
+    retainedCharacters += retainedXmlCharacters(node);
+    if (retainedCharacters > remainingRetainedCharacters) {
+      throw limitError("DOCX exceeds maxRetainedXmlCharacters", partName);
+    }
+    const parent = stack.at(-1);
+    if (parent) {
+      if (parent === root && node.type === "element" && maxRootElementChildren !== void 0) {
+        if (rootElementChildren >= maxRootElementChildren) {
+          throw limitError("Relationships part exceeds maxRelationshipsPerPart", partName);
+        }
+        rootElementChildren += 1;
+      }
+      parent.children.push(node);
+    } else if (node.type === "text" && isOnlyXmlWhitespace(node.value)) return;
+    else if (node.type === "element" && !root) root = node;
+    else
+      throw new DocxImportError(
+        "invalid_xml",
+        "XML has multiple roots or text outside the root",
+        partName
+      );
+  };
+  while (cursor < xml.length) {
+    const opening = xml.indexOf("<", cursor);
+    if (opening < 0) {
+      const tail = xml.slice(cursor);
+      if (tail.length > 0) addNode({ type: "text", value: decodeXmlEntities(tail, partName) });
+      cursor = xml.length;
+      break;
+    }
+    if (opening > cursor)
+      addNode({ type: "text", value: decodeXmlEntities(xml.slice(cursor, opening), partName) });
+    if (xml.startsWith("<!--", opening)) {
+      const end2 = xml.indexOf("-->", opening + 4);
+      const content = end2 < 0 ? "" : xml.slice(opening + 4, end2);
+      if (end2 < 0 || content.includes("--") || content.endsWith("-"))
+        throw new DocxImportError("invalid_xml", "Malformed XML comment", partName);
+      validateXmlCharacters(content, partName);
+      cursor = end2 + 3;
+      continue;
+    }
+    if (xml.startsWith("<?", opening)) {
+      const end2 = xml.indexOf("?>", opening + 2);
+      if (end2 < 0)
+        throw new DocxImportError("invalid_xml", "Malformed XML processing instruction", partName);
+      const instruction = xml.slice(opening + 2, end2);
+      const validDeclaration = /^xml[\x20\t\r\n]+version=(?:"1\.[01]"|'1\.[01]')(?:[\x20\t\r\n]+encoding=(?:"[Uu][Tt][Ff]-8"|'[Uu][Tt][Ff]-8'))?(?:[\x20\t\r\n]+standalone=(?:"(?:yes|no)"|'(?:yes|no)'))?[\x20\t\r\n]*$/.test(
+        instruction
+      );
+      if (!validDeclaration || opening !== 0 || root || stack.length > 0 || sawXmlDeclaration) {
+        throw new DocxImportError(
+          "invalid_xml",
+          "XML processing instructions are unsupported",
+          partName
+        );
+      }
+      sawXmlDeclaration = true;
+      cursor = end2 + 2;
+      continue;
+    }
+    if (xml.startsWith("<!", opening))
+      throw new DocxImportError(
+        "invalid_xml",
+        "XML declarations and CDATA are unsupported",
+        partName
+      );
+    const end = findXmlTagEnd(xml, opening + 1, partName);
+    const source = xml.slice(opening + 1, end);
+    if (source.startsWith("/")) {
+      const closing = /^\/([^\x20\t\r\n]+)[\x20\t\r\n]*$/.exec(source);
+      const name = closing?.[1];
+      if (!name || !XML_QNAME.test(name))
+        throw new DocxImportError("invalid_xml", "Malformed XML closing tag", partName);
+      const current = stack.pop();
+      if (!current || current.name !== name)
+        throw new DocxImportError("invalid_xml", "Mismatched XML closing tag", partName);
+    } else {
+      if (isXmlSpace(source[0]))
+        throw new DocxImportError("invalid_xml", "XML start tag has leading whitespace", partName);
+      const selfClosing = /\/[\x20\t\r\n]*$/.test(source);
+      const element = parseXmlStartTag(
+        selfClosing ? source.replace(/\/[\x20\t\r\n]*$/, "") : source,
+        partName,
+        maxAttributesPerElement
+      );
+      addNode(element);
+      if (!selfClosing) {
+        stack.push(element);
+        if (stack.length > maxDepth) throw limitError("XML exceeds maxXmlDepth", partName);
+      }
+    }
+    cursor = end + 1;
+  }
+  if (stack.length > 0)
+    throw new DocxImportError("invalid_xml", "XML document ended with unclosed elements", partName);
+  if (!root) throw new DocxImportError("invalid_xml", "XML root element is missing", partName);
+  return { root, nodeCount, retainedCharacters };
+}
+function retainedXmlCharacters(node) {
+  if (node.type === "text") return node.value.length;
+  let characters = node.name.length + node.localName.length;
+  for (const [name, value] of node.attributes) characters += name.length + value.length;
+  return characters;
+}
+function findXmlTagEnd(xml, start, partName) {
+  let quote;
+  for (let index = start; index < xml.length; index += 1) {
+    const character = xml[index];
+    if (quote) {
+      if (character === quote) quote = void 0;
+    } else if (character === '"' || character === "'") quote = character;
+    else if (character === ">") return index;
+  }
+  throw new DocxImportError("invalid_xml", "Unterminated XML tag", partName);
+}
+function parseXmlStartTag(source, partName, maxAttributes) {
+  let cursor = 0;
+  const skipSpace = () => {
+    while (cursor < source.length && isXmlSpace(source[cursor])) cursor += 1;
+  };
+  skipSpace();
+  const nameStart = cursor;
+  while (cursor < source.length && !isXmlSpace(source[cursor])) cursor += 1;
+  const name = source.slice(nameStart, cursor);
+  if (!XML_QNAME.test(name))
+    throw new DocxImportError("invalid_xml", "Invalid XML element name", partName);
+  const attributes = /* @__PURE__ */ new Map();
+  const localAttributeNames = /* @__PURE__ */ new Set();
+  while (cursor < source.length) {
+    if (!isXmlSpace(source[cursor]))
+      throw new DocxImportError(
+        "invalid_xml",
+        "XML attributes must be separated by whitespace",
+        partName
+      );
+    skipSpace();
+    if (cursor >= source.length) break;
+    const attributeStart = cursor;
+    while (cursor < source.length && !isXmlSpace(source[cursor]) && source[cursor] !== "=")
+      cursor += 1;
+    const attributeName = source.slice(attributeStart, cursor);
+    if (!XML_QNAME.test(attributeName))
+      throw new DocxImportError("invalid_xml", "Invalid XML attribute name", partName);
+    skipSpace();
+    if (source[cursor] !== "=")
+      throw new DocxImportError("invalid_xml", "XML attribute lacks a value", partName);
+    cursor += 1;
+    skipSpace();
+    const quote = source[cursor];
+    if (quote !== '"' && quote !== "'")
+      throw new DocxImportError("invalid_xml", "XML attribute value must be quoted", partName);
+    cursor += 1;
+    const valueStart = cursor;
+    const valueEnd = source.indexOf(quote, valueStart);
+    if (valueEnd < 0)
+      throw new DocxImportError("invalid_xml", "Unterminated XML attribute value", partName);
+    if (attributes.has(attributeName))
+      throw new DocxImportError("invalid_xml", "Duplicate XML attribute", partName);
+    if (attributes.size >= maxAttributes)
+      throw limitError("XML element exceeds maxXmlAttributesPerElement", partName);
+    const attributeLocalName = localName(attributeName);
+    const namespaceDeclaration = attributeName === "xmlns" || attributeName.startsWith("xmlns:");
+    if (!namespaceDeclaration && localAttributeNames.has(attributeLocalName)) {
+      throw new DocxImportError(
+        "invalid_xml",
+        "Ambiguous namespace-local XML attributes",
+        partName
+      );
+    }
+    localAttributeNames.add(attributeLocalName);
+    const rawValue = source.slice(valueStart, valueEnd);
+    if (rawValue.includes("<"))
+      throw new DocxImportError(
+        "invalid_xml",
+        "XML attribute contains an unescaped less-than sign",
+        partName
+      );
+    attributes.set(attributeName, decodeXmlEntities(rawValue, partName));
+    cursor = valueEnd + 1;
+  }
+  return { type: "element", name, localName: localName(name), attributes, children: [] };
+}
+var XML_QNAME = /^(?:[A-Za-z_][A-Za-z0-9_.-]*:)?[A-Za-z_][A-Za-z0-9_.-]*$/;
+function isXmlSpace(value) {
+  return value === " " || value === "	" || value === "\r" || value === "\n";
+}
+function isOnlyXmlWhitespace(value) {
+  for (let index = 0; index < value.length; index += 1) if (!isXmlSpace(value[index])) return false;
+  return true;
+}
+function decodeXmlEntities(value, partName) {
+  validateXmlCharacters(value, partName);
+  if (value.includes("]]>"))
+    throw new DocxImportError("invalid_xml", "XML contains malformed character data", partName);
+  let ampersand = value.indexOf("&");
+  if (ampersand < 0) return value;
+  const output = [];
+  let cursor = 0;
+  let referenceCount = 0;
+  while (ampersand >= 0) {
+    referenceCount += 1;
+    if (referenceCount > 65536)
+      throw limitError("XML text node exceeds the entity-reference safety cap", partName);
+    output.push(value.slice(cursor, ampersand));
+    const semicolon = value.indexOf(";", ampersand + 1);
+    const nestedAmpersand = value.indexOf("&", ampersand + 1);
+    if (semicolon < 0 || nestedAmpersand >= 0 && nestedAmpersand < semicolon) {
+      throw new DocxImportError(
+        "invalid_xml",
+        "XML contains an unterminated entity reference",
+        partName
+      );
+    }
+    const entity = value.slice(ampersand + 1, semicolon);
+    if (entity.length === 0 || entity.length > 16) {
+      throw new DocxImportError(
+        "invalid_xml",
+        "XML contains a malformed entity reference",
+        partName
+      );
+    }
+    output.push(decodeXmlEntity(entity, partName));
+    cursor = semicolon + 1;
+    ampersand = value.indexOf("&", cursor);
+  }
+  output.push(value.slice(cursor));
+  return output.join("");
+}
+function decodeXmlEntity(entity, partName) {
+  if (entity === "amp") return "&";
+  if (entity === "lt") return "<";
+  if (entity === "gt") return ">";
+  if (entity === "quot") return '"';
+  if (entity === "apos") return "'";
+  const decimal = /^#([0-9]+)$/.exec(entity);
+  const hex = /^#x([0-9a-f]+)$/i.exec(entity);
+  const codePoint = decimal ? Number(decimal[1]) : hex ? Number.parseInt(hex[1] ?? "", 16) : NaN;
+  if (!Number.isInteger(codePoint) || !isValidXmlCodePoint(codePoint)) {
+    throw new DocxImportError(
+      "invalid_xml",
+      `Unsupported or invalid XML entity: &${entity};`,
+      partName
+    );
+  }
+  return String.fromCodePoint(codePoint);
+}
+function validateXmlCharacters(value, partName) {
+  for (const character of value) {
+    const codePoint = character.codePointAt(0) ?? 0;
+    if (!isValidXmlCodePoint(codePoint)) {
+      throw new DocxImportError("invalid_xml", "XML contains a forbidden character", partName);
+    }
+  }
+}
+function isValidXmlCodePoint(codePoint) {
+  return codePoint === 9 || codePoint === 10 || codePoint === 13 || codePoint >= 32 && codePoint <= 55295 || codePoint >= 57344 && codePoint <= 65533 || codePoint >= 65536 && codePoint <= 1114111;
+}
+function validateContentTypes(root, parts) {
+  requireLocalName(root, "Types", "[Content_Types].xml");
+  requireDefaultNamespaceTree(root, CONTENT_TYPES_NAMESPACE, "[Content_Types].xml");
+  const defaults = /* @__PURE__ */ new Map();
+  const overrides = /* @__PURE__ */ new Map();
+  for (const entry of elementChildren(root)) {
+    if (entry.name !== "Default" && entry.name !== "Override" || entry.localName !== entry.name) {
+      throw new DocxImportError(
+        "invalid_package",
+        "Unknown content-type declaration",
+        "[Content_Types].xml"
+      );
+    }
+    assertExactAttributes(
+      entry,
+      entry.name === "Default" ? /* @__PURE__ */ new Set(["Extension", "ContentType"]) : /* @__PURE__ */ new Set(["PartName", "ContentType"]),
+      "[Content_Types].xml"
+    );
+    requireLeafElement(entry, "[Content_Types].xml");
+    const contentType = exactAttribute(entry, "ContentType") ?? "";
+    if (contentType.length === 0)
+      throw new DocxImportError(
+        "invalid_package",
+        "Content-type declaration lacks ContentType",
+        "[Content_Types].xml"
+      );
+    if (/(?:macroEnabled|vbaProject|activeX|oleObject|encryptedPackage|digital-signature|customUI|webExtension)/i.test(
+      contentType
+    )) {
+      throw new DocxImportError(
+        "unsupported_feature",
+        `Unsupported DOCX content type: ${contentType}`,
+        "[Content_Types].xml"
+      );
+    }
+    if (entry.localName === "Default") {
+      const extension = requiredExactAttribute(
+        entry,
+        "Extension",
+        "[Content_Types].xml"
+      ).toLowerCase();
+      if (!/^[a-z0-9]+$/.test(extension) || defaults.has(extension)) {
+        throw new DocxImportError(
+          "invalid_package",
+          "Invalid or duplicate default content type",
+          "[Content_Types].xml"
+        );
+      }
+      defaults.set(extension, contentType);
+    } else {
+      const declared = requiredExactAttribute(entry, "PartName", "[Content_Types].xml");
+      if (declared.length > 1025)
+        throw limitError("Override PartName exceeds its safety cap", "[Content_Types].xml");
+      if (!declared.startsWith("/") || declared.includes("\\") || /%(?:2e|2f|5c)/i.test(declared)) {
+        throw new DocxImportError(
+          "invalid_package",
+          "Unsafe override PartName",
+          "[Content_Types].xml"
+        );
+      }
+      const partName = declared.slice(1);
+      let segmentCount = 1;
+      for (let index = 0; index < partName.length; index += 1) {
+        if (partName.charCodeAt(index) === 47 && ++segmentCount > 256) {
+          throw limitError(
+            "Override PartName exceeds its path-segment safety cap",
+            "[Content_Types].xml"
+          );
+        }
+      }
+      const segments = partName.split("/");
+      if (segments.some((segment) => segment === "" || segment === "." || segment === "..")) {
+        throw new DocxImportError(
+          "invalid_package",
+          "Unsafe override PartName",
+          "[Content_Types].xml"
+        );
+      }
+      const key = partName.toLowerCase();
+      if (overrides.has(key))
+        throw new DocxImportError(
+          "invalid_package",
+          "Duplicate override content type",
+          "[Content_Types].xml"
+        );
+      if (!parts.has(partName))
+        throw new DocxImportError(
+          "invalid_package",
+          "Content-type override targets a missing part",
+          partName
+        );
+      overrides.set(key, contentType);
+    }
+  }
+  const contentTypeByPart = /* @__PURE__ */ new Map();
+  for (const partName of parts.keys()) {
+    if (partName === "[Content_Types].xml") continue;
+    const extensionIndex = partName.lastIndexOf(".");
+    const extension = extensionIndex < 0 ? "" : partName.slice(extensionIndex + 1).toLowerCase();
+    const contentType = overrides.get(partName.toLowerCase()) ?? defaults.get(extension);
+    if (!contentType) {
+      throw new DocxImportError(
+        "invalid_package",
+        "Package part has no declared content type",
+        partName
+      );
+    }
+    contentTypeByPart.set(partName, contentType);
+  }
+  const documentType = overrides.get("word/document.xml");
+  if (documentType !== "application/vnd.openxmlformats-officedocument.wordprocessingml.document.main+xml") {
+    throw new DocxImportError(
+      "invalid_package",
+      "word/document.xml has the wrong content type",
+      "[Content_Types].xml"
+    );
+  }
+  return contentTypeByPart;
+}
+function isSafeOpaqueContentType(partName, contentType) {
+  if (/(?:macroEnabled|vbaProject|activeX|oleObject|encryptedPackage|digital-signature|customUI|webExtension)/i.test(
+    contentType
+  )) {
+    return false;
+  }
+  if (partName.endsWith(".rels")) {
+    return contentType === "application/vnd.openxmlformats-package.relationships+xml";
+  }
+  return /^(?:application|text)\/xml$/i.test(contentType) || /^(?:application|text)\/[A-Za-z0-9!#$&^_.+-]+\+xml$/i.test(contentType);
+}
+function parseRelationships(root, relationshipsPart, maxRelationships) {
+  requireLocalName(root, "Relationships", relationshipsPart);
+  requireDefaultNamespaceTree(root, RELATIONSHIPS_NAMESPACE, relationshipsPart);
+  const sourcePart = relationshipSourcePart(relationshipsPart);
+  const relationships = [];
+  const ids = /* @__PURE__ */ new Set();
+  for (const child of elementChildren(root)) {
+    if (relationships.length >= maxRelationships)
+      throw limitError("Relationships part exceeds maxRelationshipsPerPart", relationshipsPart);
+    if (child.name !== "Relationship")
+      throw new DocxImportError(
+        "invalid_package",
+        "Unknown relationship element",
+        relationshipsPart
+      );
+    requireLeafElement(child, relationshipsPart);
+    assertExactAttributes(
+      child,
+      /* @__PURE__ */ new Set(["Id", "Type", "Target", "TargetMode"]),
+      relationshipsPart
+    );
+    const id = requiredExactAttribute(child, "Id", relationshipsPart);
+    const type = requiredExactAttribute(child, "Type", relationshipsPart);
+    const target = requiredExactAttribute(child, "Target", relationshipsPart);
+    if (id.length > 512 || type.length > 2048 || target.length > 4096) {
+      throw limitError(
+        "Relationship Id, Type, or Target exceeds its safety cap",
+        relationshipsPart
+      );
+    }
+    if (ids.has(id))
+      throw new DocxImportError("invalid_package", "Duplicate relationship id", relationshipsPart);
+    ids.add(id);
+    if ((exactAttribute(child, "TargetMode") ?? "Internal") !== "Internal") {
+      throw new DocxImportError(
+        "unsupported_feature",
+        "External DOCX relationships are unsupported",
+        relationshipsPart
+      );
+    }
+    relationships.push({
+      id,
+      type,
+      target,
+      sourcePart,
+      partName: resolvePartTarget(sourcePart, target, relationshipsPart)
+    });
+  }
+  return relationships;
+}
+function validateRelationships(relationships, opaqueParts) {
+  const allowed = /* @__PURE__ */ new Set([
+    `${WORD_RELATIONSHIP_BASE}officeDocument`,
+    `${WORD_RELATIONSHIP_BASE}styles`,
+    `${WORD_RELATIONSHIP_BASE}settings`,
+    `${WORD_RELATIONSHIP_BASE}webSettings`,
+    `${WORD_RELATIONSHIP_BASE}theme`,
+    `${WORD_RELATIONSHIP_BASE}fontTable`,
+    `${WORD_RELATIONSHIP_BASE}numbering`,
+    `${WORD_RELATIONSHIP_BASE}header`,
+    `${WORD_RELATIONSHIP_BASE}footer`,
+    `${WORD_RELATIONSHIP_BASE}comments`,
+    "http://schemas.microsoft.com/office/2011/relationships/commentsExtended",
+    `${WORD_RELATIONSHIP_BASE}footnotes`,
+    `${WORD_RELATIONSHIP_BASE}endnotes`,
+    `${PACKAGE_RELATIONSHIP_BASE}core-properties`,
+    "http://schemas.openxmlformats.org/officeDocument/2006/relationships/extended-properties",
+    "http://schemas.openxmlformats.org/officeDocument/2006/relationships/custom-properties"
+  ]);
+  const opaqueRelationships = [];
+  for (const relationship of relationships) {
+    if (allowed.has(relationship.type)) {
+      validateRelationshipRoute(relationship);
+      if (opaqueParts.has(relationship.partName)) opaqueRelationships.push(relationship);
+      continue;
+    }
+    if (!isSafeOpaqueRelationship(relationship) || !opaqueParts.has(relationship.partName)) {
+      throw new DocxImportError(
+        "unsupported_feature",
+        `Unsupported DOCX relationship: ${relationship.type}`,
+        relationship.partName
+      );
+    }
+    opaqueRelationships.push(relationship);
+  }
+  const singletonTypes = new Set(
+    [
+      "styles",
+      "settings",
+      "webSettings",
+      "theme",
+      "fontTable",
+      "numbering",
+      "comments",
+      "footnotes",
+      "endnotes"
+    ].map((suffix) => `${WORD_RELATIONSHIP_BASE}${suffix}`).concat(["http://schemas.microsoft.com/office/2011/relationships/commentsExtended"])
+  );
+  const seenSingletons = /* @__PURE__ */ new Set();
+  for (const relationship of relationships) {
+    if (relationship.sourcePart !== "word/document.xml" || !singletonTypes.has(relationship.type))
+      continue;
+    if (seenSingletons.has(relationship.type)) {
+      throw new DocxImportError(
+        "invalid_package",
+        "Document contains duplicate singleton relationships",
+        relationship.partName
+      );
+    }
+    seenSingletons.add(relationship.type);
+  }
+  return opaqueRelationships;
+}
+function isSafeOpaqueRelationship(relationship) {
+  const { sourcePart, type, partName } = relationship;
+  if (type === `${WORD_RELATIONSHIP_BASE}customXml`) {
+    return sourcePart === "word/document.xml" && /^customXml\/item\d+\.xml$/.test(partName);
+  }
+  if (type === `${WORD_RELATIONSHIP_BASE}customXmlProps`) {
+    return /^customXml\/item\d+\.xml$/.test(sourcePart) && /^customXml\/itemProps\d+\.xml$/.test(partName);
+  }
+  if (type === `${WORD_RELATIONSHIP_BASE}glossaryDocument`) {
+    return sourcePart === "word/document.xml" && partName === "word/glossary/document.xml";
+  }
+  return false;
+}
+function validateRelationshipRoute(relationship) {
+  const { sourcePart, type, partName } = relationship;
+  if (sourcePart === "") {
+    const expected = (/* @__PURE__ */ new Map([
+      [`${WORD_RELATIONSHIP_BASE}officeDocument`, "word/document.xml"],
+      [`${PACKAGE_RELATIONSHIP_BASE}core-properties`, "docProps/core.xml"],
+      [
+        "http://schemas.openxmlformats.org/officeDocument/2006/relationships/extended-properties",
+        "docProps/app.xml"
+      ],
+      [
+        "http://schemas.openxmlformats.org/officeDocument/2006/relationships/custom-properties",
+        "docProps/custom.xml"
+      ]
+    ])).get(type);
+    if (!expected || partName !== expected) {
+      throw new DocxImportError(
+        "invalid_package",
+        "Package-root relationship has an invalid type or target",
+        partName
+      );
+    }
+    return;
+  }
+  if (sourcePart !== "word/document.xml") {
+    throw new DocxImportError(
+      "unsupported_feature",
+      "Relationships from auxiliary Word parts are not yet supported",
+      sourcePart
+    );
+  }
+  const fixedTargets = /* @__PURE__ */ new Map([
+    [`${WORD_RELATIONSHIP_BASE}styles`, "word/styles.xml"],
+    [`${WORD_RELATIONSHIP_BASE}settings`, "word/settings.xml"],
+    [`${WORD_RELATIONSHIP_BASE}webSettings`, "word/webSettings.xml"],
+    [`${WORD_RELATIONSHIP_BASE}fontTable`, "word/fontTable.xml"],
+    [`${WORD_RELATIONSHIP_BASE}numbering`, "word/numbering.xml"],
+    [`${WORD_RELATIONSHIP_BASE}comments`, "word/comments.xml"],
+    [`${WORD_RELATIONSHIP_BASE}footnotes`, "word/footnotes.xml"],
+    [`${WORD_RELATIONSHIP_BASE}endnotes`, "word/endnotes.xml"],
+    [
+      "http://schemas.microsoft.com/office/2011/relationships/commentsExtended",
+      "word/commentsExtended.xml"
+    ]
+  ]);
+  const fixed = fixedTargets.get(type);
+  const valid = fixed !== void 0 ? partName === fixed : type === `${WORD_RELATIONSHIP_BASE}theme` ? /^word\/theme\/theme\d+\.xml$/.test(partName) : type === `${WORD_RELATIONSHIP_BASE}header` ? /^word\/header\d+\.xml$/.test(partName) : type === `${WORD_RELATIONSHIP_BASE}footer` && /^word\/footer\d+\.xml$/.test(partName);
+  if (!valid)
+    throw new DocxImportError(
+      "invalid_package",
+      "Document relationship has an invalid type or target",
+      partName
+    );
+}
+function validateRelationshipCoverage(parts, relationships) {
+  const targets = new Set(relationships.map((relationship) => relationship.partName));
+  for (const partName of parts.keys()) {
+    if (partName === "[Content_Types].xml" || partName.endsWith(".rels")) continue;
+    if (!targets.has(partName))
+      throw new DocxImportError(
+        "invalid_package",
+        "Package contains an orphaned content part",
+        partName
+      );
+  }
+  for (const partName of parts.keys()) {
+    if (!partName.endsWith(".rels") || partName === "_rels/.rels") continue;
+    const sourcePart = relationshipSourcePart(partName);
+    if (!parts.has(sourcePart))
+      throw new DocxImportError(
+        "invalid_package",
+        "Relationships part has no source part",
+        partName
+      );
+  }
+}
+function validateEmptyNotePart(root, itemName, partName) {
+  requireLocalName(root, `${itemName}s`, partName);
+  requireWordNamespace(root, partName);
+  for (const item of elementChildren(root)) {
+    if (item.localName !== itemName)
+      throw new DocxImportError("invalid_package", `Unknown ${itemName} element`, partName);
+    const id = Number(requiredAttribute(item, "id", partName));
+    const type = attribute(item, "type");
+    if (!Number.isInteger(id) || type !== "separator" && type !== "continuationSeparator") {
+      throw new DocxImportError(
+        "unsupported_feature",
+        `DOCX ${itemName}s are not yet supported`,
+        partName
+      );
+    }
+  }
+}
+function validateSettings(root) {
+  requireLocalName(root, "settings", "word/settings.xml");
+  requireWordNamespace(root, "word/settings.xml");
+  assertAllowedContentChildren(
+    root,
+    /* @__PURE__ */ new Set([
+      "displayBackgroundShape",
+      "evenAndOddHeaders",
+      "trackRevisions",
+      "compat",
+      "documentProtection",
+      "writeProtection"
+    ]),
+    "document settings"
+  );
+  for (const protectedFeature of ["documentProtection", "writeProtection"]) {
+    if (firstChild(root, protectedFeature)) {
+      throw new DocxImportError(
+        "unsupported_feature",
+        `DOCX ${protectedFeature} is not preserved by import`,
+        "word/settings.xml"
+      );
+    }
+  }
+  const background = singletonChild(root, "displayBackgroundShape", "document settings");
+  const evenAndOdd = singletonChild(root, "evenAndOddHeaders", "document settings");
+  const trackRevisions = singletonChild(root, "trackRevisions", "document settings");
+  const compat = singletonChild(root, "compat", "document settings");
+  assertAllowedAttributes(background, /* @__PURE__ */ new Set(["val"]), "display-background-shape setting");
+  assertAllowedAttributes(evenAndOdd, /* @__PURE__ */ new Set(["val"]), "even-and-odd-headers setting");
+  assertAllowedAttributes(trackRevisions, /* @__PURE__ */ new Set(["val"]), "track-revisions setting");
+  assertAllowedAttributes(compat, /* @__PURE__ */ new Set(), "compatibility settings");
+  assertAllowedContentChildren(background, /* @__PURE__ */ new Set(), "display-background-shape setting");
+  assertAllowedContentChildren(evenAndOdd, /* @__PURE__ */ new Set(), "even-and-odd-headers setting");
+  assertAllowedContentChildren(trackRevisions, /* @__PURE__ */ new Set(), "track-revisions setting");
+  const tracksRevisions = booleanValue(trackRevisions, false);
+  assertAllowedContentChildren(compat, /* @__PURE__ */ new Set(["compatSetting"]), "compatibility settings");
+  const seenCompat = /* @__PURE__ */ new Set();
+  for (const setting of children(compat, "compatSetting")) {
+    assertAllowedAttributes(setting, /* @__PURE__ */ new Set(["name", "uri", "val"]), "compatibility setting");
+    assertAllowedContentChildren(setting, /* @__PURE__ */ new Set(), "compatibility setting");
+    const name = attribute(setting, "name");
+    const uri = attribute(setting, "uri");
+    const value = attribute(setting, "val");
+    const key = `${uri ?? ""}\0${name ?? ""}`;
+    if (seenCompat.has(key))
+      throw new DocxImportError(
+        "invalid_package",
+        "Duplicate compatibility setting",
+        "word/settings.xml"
+      );
+    seenCompat.add(key);
+    if (name !== "compatibilityMode" || uri !== "http://schemas.microsoft.com/office/word" || value !== "15") {
+      throw new DocxImportError(
+        "unsupported_feature",
+        "Document compatibility setting is not represented",
+        "word/settings.xml"
+      );
+    }
+  }
+  return { evenAndOddHeaders: booleanValue(evenAndOdd, false), trackRevisions: tracksRevisions };
+}
+function parseMainDocument(root, context, relationships) {
+  requireLocalName(root, "document", "word/document.xml");
+  rejectUnsupportedContent(root, "word/document.xml");
+  requireWordNamespace(root, "word/document.xml");
+  const body = onlyElement(root, "body", "word/document.xml");
+  const blocks = [];
+  const sections = [];
+  let sectionStart = 0;
+  const addSection = (section) => {
+    if (sections.length >= context.budget.limits.maxSections) {
+      throw limitError("DOCX exceeds maxSections", "word/document.xml");
+    }
+    sections.push(section);
+  };
+  for (const child of elementChildren(body)) {
+    if (child.localName === "p") {
+      const sectionProperties = firstChild(firstChild(child, "pPr"), "sectPr");
+      if (!sectionProperties || !isPureSectionBoundaryParagraph(child)) {
+        blocks.push(parseParagraph(child, context));
+      }
+      if (sectionProperties) {
+        addSection(parseSection(sectionProperties, sectionStart, blocks.length, relationships));
+        sectionStart = blocks.length;
+      }
+    } else if (child.localName === "tbl") blocks.push(parseTable(child, context));
+    else if (child.localName === "sectPr") {
+      addSection(parseSection(child, sectionStart, blocks.length, relationships));
+      sectionStart = blocks.length;
+    } else if (!NON_CONTENT_MARKERS.has(child.localName)) {
+      throw unsupportedElement(child, "word/document.xml");
+    }
+  }
+  if (sections.length === 0 || sectionStart < blocks.length) {
+    addSection(defaultSection(sectionStart, blocks.length));
+  }
+  return { blocks, sections };
+}
+function parseBlockContainer(root, context) {
+  rejectUnsupportedContent(root, context.idPrefix);
+  const blocks = [];
+  for (const child of elementChildren(root)) {
+    if (child.localName === "p") blocks.push(parseParagraph(child, context));
+    else if (child.localName === "tbl") blocks.push(parseTable(child, context));
+    else if (!NON_CONTENT_MARKERS.has(child.localName))
+      throw unsupportedElement(child, context.idPrefix);
+  }
+  return blocks;
+}
+function parseParagraph(element, context) {
+  consumeBlock(context.budget);
+  const id = `${context.idPrefix}:p${context.budget.nextBlockId++}`;
+  const properties = singletonChild(element, "pPr", "paragraph");
+  const styleId = valueOf(firstChild(properties, "pStyle"));
+  const paragraph = {
+    kind: "paragraph",
+    id,
+    ...styleId !== void 0 ? { styleId } : {},
+    style: parseParagraphProperties(properties),
+    inlines: [],
+    commentAnchors: []
+  };
+  const firstTrackedChange = context.trackedChanges.length;
+  let textOffset = 0;
+  const addRun = (run) => {
+    paragraph.inlines.push(run);
+    if (run.kind === "run") {
+      textOffset += run.text.length;
+      consumeText(context.budget, run.text.length);
+    }
+  };
+  const parseChildren = (parent, change) => {
+    for (const child of elementChildren(parent)) {
+      if (child.localName === "pPr") continue;
+      if (child.localName === "r") {
+        const paragraphOffset = textOffset;
+        const parsed = parseRun(child, change, (commentId, runOffset) => {
+          paragraph.commentAnchors.push({
+            commentId,
+            kind: "reference",
+            textOffset: paragraphOffset + runOffset
+          });
+        });
+        for (const inline of parsed) addRun(inline);
+      } else if (child.localName === "ins" || child.localName === "del") {
+        if (change)
+          throw new DocxImportError(
+            "invalid_package",
+            "Tracked changes cannot be nested",
+            context.idPrefix
+          );
+        const changeStart = paragraph.inlines.length;
+        const changeTextStart = textOffset;
+        const author = attribute(child, "author");
+        const createdAt = attribute(child, "date");
+        const metadata = {
+          id: requiredAttribute(child, "id", context.idPrefix),
+          kind: child.localName === "ins" ? "insert" : "delete",
+          ...author !== void 0 ? { author } : {},
+          ...createdAt !== void 0 ? { createdAt } : {}
+        };
+        parseChildren(child, metadata);
+        context.trackedChanges.push({
+          id: metadata.id,
+          kind: metadata.kind,
+          ...metadata.author !== void 0 ? { author: metadata.author } : {},
+          ...metadata.createdAt !== void 0 ? { createdAt: metadata.createdAt } : {},
+          blockId: id,
+          startInlineIndex: changeStart,
+          endInlineIndex: paragraph.inlines.length,
+          startTextOffset: changeTextStart,
+          endTextOffset: textOffset
+        });
+      } else if (child.localName === "commentRangeStart" || child.localName === "commentRangeEnd") {
+        paragraph.commentAnchors.push({
+          commentId: requiredAttribute(child, "id", context.idPrefix),
+          kind: child.localName === "commentRangeStart" ? "start" : "end",
+          textOffset
+        });
+      } else if (child.localName === "commentReference") {
+        paragraph.commentAnchors.push({
+          commentId: requiredAttribute(child, "id", context.idPrefix),
+          kind: "reference",
+          textOffset
+        });
+      } else if (!NON_CONTENT_MARKERS.has(child.localName))
+        throw unsupportedElement(child, context.idPrefix);
+    }
+  };
+  parseChildren(element);
+  validateScalarBoundaries(paragraph, context.trackedChanges, firstTrackedChange, context.idPrefix);
+  return stripUndefined(paragraph);
+}
+function isPureSectionBoundaryParagraph(element) {
+  const paragraphChildren = elementChildren(element);
+  if (paragraphChildren.length !== 1 || paragraphChildren[0]?.localName !== "pPr") return false;
+  const propertyChildren = elementChildren(paragraphChildren[0]);
+  return propertyChildren.length === 1 && propertyChildren[0]?.localName === "sectPr";
+}
+function validateScalarBoundaries(paragraph, trackedChanges, firstTrackedChange, partName) {
+  const chunks = [];
+  for (const inline of paragraph.inlines) if (inline.kind === "run") chunks.push(inline.text);
+  const text = chunks.join("");
+  const validate = (offset, label) => {
+    if (!Number.isInteger(offset) || offset < 0 || offset > text.length) {
+      throw new DocxImportError("invalid_package", `${label} is outside its paragraph`, partName);
+    }
+    const before = offset > 0 ? text.charCodeAt(offset - 1) : 0;
+    const after = offset < text.length ? text.charCodeAt(offset) : 0;
+    if (before >= 55296 && before <= 56319 && after >= 56320 && after <= 57343) {
+      throw new DocxImportError(
+        "invalid_package",
+        `${label} splits a Unicode scalar value`,
+        partName
+      );
+    }
+  };
+  for (const anchor of paragraph.commentAnchors) validate(anchor.textOffset, "Comment anchor");
+  for (let index = firstTrackedChange; index < trackedChanges.length; index += 1) {
+    const change = trackedChanges[index];
+    if (!change || change.blockId !== paragraph.id) continue;
+    validate(change.startTextOffset, "Tracked-change start");
+    validate(change.endTextOffset, "Tracked-change end");
+  }
+}
+function parseRun(element, change, onCommentReference) {
+  const properties = singletonChild(element, "rPr", "run");
+  const styleId = valueOf(firstChild(properties, "rStyle"));
+  const style = parseRunProperties(properties);
+  const styled = styleId !== void 0 || Object.keys(style).length > 0;
+  const inlines = [];
+  let text = "";
+  let emittedTextLength = 0;
+  let hasCommentReference = false;
+  const flush = () => {
+    if (text.length === 0) return;
+    inlines.push(
+      stripUndefined({
+        kind: "run",
+        text,
+        styleId,
+        style,
+        changeId: change?.id
+      })
+    );
+    emittedTextLength += text.length;
+    text = "";
+  };
+  for (const child of elementChildren(element)) {
+    if (child.localName === "rPr") continue;
+    if (child.localName === "t" || child.localName === "delText") text += textContent(child);
+    else if (child.localName === "tab") text += "	";
+    else if (child.localName === "cr") text += "\n";
+    else if (child.localName === "noBreakHyphen") text += "\u2011";
+    else if (child.localName === "softHyphen") text += "\xAD";
+    else if (child.localName === "br") {
+      assertAllowedAttributes(child, /* @__PURE__ */ new Set(["type"]), "run break");
+      assertAllowedContentChildren(child, /* @__PURE__ */ new Set(), "run break");
+      const type = attribute(child, "type") ?? "textWrapping";
+      if (type === "page") {
+        flush();
+        inlines.push({ kind: "pageBreak" });
+      } else if (type === "textWrapping") text += "\n";
+      else throw new DocxImportError("unsupported_feature", `Unsupported break type: ${type}`);
+    } else if (child.localName === "commentReference") {
+      hasCommentReference = true;
+      const commentId = requiredAttribute(child, "id", "word/document.xml");
+      onCommentReference?.(commentId, emittedTextLength + text.length);
+    } else if (child.localName !== "lastRenderedPageBreak" && !NON_CONTENT_MARKERS.has(child.localName)) {
+      throw unsupportedElement(child, "word/document.xml");
+    }
+  }
+  flush();
+  if (emittedTextLength === 0 && styled && (hasCommentReference || inlines.length > 0)) {
+    throw new DocxImportError(
+      "unsupported_feature",
+      "Formatting on a non-text run cannot be represented without changing marker behavior",
+      "word/document.xml"
+    );
+  }
+  if (emittedTextLength === 0 && inlines.length === 0 && !hasCommentReference) {
+    inlines.push(
+      stripUndefined({
+        kind: "run",
+        text: "",
+        styleId,
+        style,
+        changeId: change?.id
+      })
+    );
+  }
+  return inlines;
+}
+function parseTable(element, context) {
+  consumeBlock(context.budget);
+  assertAllowedContentChildren(element, /* @__PURE__ */ new Set(["tblPr", "tblGrid", "tr"]), "table");
+  const id = `${context.idPrefix}:tbl${context.budget.nextBlockId++}`;
+  const properties = singletonChild(element, "tblPr", "table");
+  assertAllowedPropertyChildren(
+    properties,
+    /* @__PURE__ */ new Set(["tblStyle", "tblW", "tblInd", "jc", "tblLayout", "tblCellMar", "tblBorders"]),
+    "table properties"
+  );
+  assertUniqueChildNames(properties, "table properties");
+  assertAllowedAttributes(firstChild(properties, "tblStyle"), /* @__PURE__ */ new Set(["val"]), "table style");
+  assertAllowedAttributes(firstChild(properties, "jc"), /* @__PURE__ */ new Set(["val"]), "table alignment");
+  const grid = singletonChild(element, "tblGrid", "table");
+  assertAllowedContentChildren(grid, /* @__PURE__ */ new Set(["gridCol"]), "table grid");
+  assertAllowedAttributes(grid, /* @__PURE__ */ new Set(), "table grid");
+  for (const column of children(grid, "gridCol")) {
+    assertAllowedAttributes(column, /* @__PURE__ */ new Set(["w"]), "table grid column");
+    assertAllowedContentChildren(column, /* @__PURE__ */ new Set(), "table grid column");
+  }
+  const rows = [];
+  for (const rowElement of children(element, "tr")) {
+    assertAllowedContentChildren(rowElement, /* @__PURE__ */ new Set(["trPr", "tc"]), "table row");
+    const rowProperties = singletonChild(rowElement, "trPr", "table row");
+    assertAllowedPropertyChildren(
+      rowProperties,
+      /* @__PURE__ */ new Set(["tblHeader", "cantSplit", "trHeight"]),
+      "table row properties"
+    );
+    assertUniqueChildNames(rowProperties, "table row properties");
+    assertAllowedAttributes(rowProperties, /* @__PURE__ */ new Set(), "table row properties");
+    assertAllowedAttributes(
+      firstChild(rowProperties, "tblHeader"),
+      /* @__PURE__ */ new Set(["val"]),
+      "table header-row setting"
+    );
+    assertAllowedAttributes(
+      firstChild(rowProperties, "cantSplit"),
+      /* @__PURE__ */ new Set(["val"]),
+      "table row-splitting setting"
+    );
+    assertAllowedAttributes(
+      firstChild(rowProperties, "trHeight"),
+      /* @__PURE__ */ new Set(["val", "hRule"]),
+      "table row height"
+    );
+    const cells = [];
+    for (const cellElement of children(rowElement, "tc")) {
+      assertAllowedContentChildren(cellElement, /* @__PURE__ */ new Set(["tcPr", "p", "tbl"]), "table cell");
+      const cellProperties = singletonChild(cellElement, "tcPr", "table cell");
+      assertAllowedPropertyChildren(
+        cellProperties,
+        /* @__PURE__ */ new Set(["tcW", "tcMar", "gridSpan", "vMerge", "vAlign", "shd"]),
+        "table cell properties"
+      );
+      assertUniqueChildNames(cellProperties, "table cell properties");
+      assertAllowedAttributes(cellProperties, /* @__PURE__ */ new Set(), "table cell properties");
+      for (const name of ["gridSpan", "vMerge", "vAlign"]) {
+        assertAllowedAttributes(
+          firstChild(cellProperties, name),
+          /* @__PURE__ */ new Set(["val"]),
+          `table cell ${name}`
+        );
+      }
+      const verticalMergeElement = firstChild(cellProperties, "vMerge");
+      const verticalMergeValue = verticalMergeElement ? valueOf(verticalMergeElement) ?? "continue" : void 0;
+      if (verticalMergeValue !== void 0 && verticalMergeValue !== "restart" && verticalMergeValue !== "continue") {
+        throw new DocxImportError(
+          "invalid_package",
+          `Invalid vertical merge value: ${verticalMergeValue}`,
+          context.idPrefix
+        );
+      }
+      const columnSpan = integerValue(firstChild(cellProperties, "gridSpan"), 1);
+      if (columnSpan < 1)
+        throw new DocxImportError(
+          "invalid_package",
+          "Table gridSpan must be positive",
+          context.idPrefix
+        );
+      const blocks = [];
+      for (const block of elementChildren(cellElement)) {
+        if (block.localName === "tcPr") continue;
+        if (block.localName === "p") blocks.push(parseParagraph(block, context));
+        else if (block.localName === "tbl") blocks.push(parseTable(block, context));
+        else if (!NON_CONTENT_MARKERS.has(block.localName))
+          throw unsupportedElement(block, context.idPrefix);
+      }
+      const shading = firstChild(cellProperties, "shd");
+      validateShading(shading, context.idPrefix);
+      cells.push(
+        stripUndefined({
+          width: parseMeasure(firstChild(cellProperties, "tcW")),
+          margins: parseBoxMeasures(firstChild(cellProperties, "tcMar"), "table cell margins"),
+          columnSpan,
+          verticalMerge: verticalMergeValue === void 0 ? void 0 : verticalMergeValue === "restart" ? "restart" : "continue",
+          verticalAlignment: valueOf(firstChild(cellProperties, "vAlign")),
+          fill: attribute(shading, "fill"),
+          blocks
+        })
+      );
+    }
+    const height = firstChild(rowProperties, "trHeight");
+    const heightRule = attribute(height, "hRule");
+    if (heightRule !== void 0 && heightRule !== "auto" && heightRule !== "atLeast" && heightRule !== "exact") {
+      throw new DocxImportError(
+        "invalid_package",
+        `Invalid table row height rule: ${heightRule}`,
+        context.idPrefix
+      );
+    }
+    rows.push(
+      stripUndefined({
+        header: booleanValue(firstChild(rowProperties, "tblHeader"), false),
+        cannotSplit: booleanValue(firstChild(rowProperties, "cantSplit"), false),
+        heightPt: numberAttribute(height, "val", twipsToPt),
+        heightRule,
+        cells
+      })
+    );
+  }
+  return stripUndefined({
+    kind: "table",
+    id,
+    styleId: valueOf(firstChild(properties, "tblStyle")),
+    width: parseMeasure(firstChild(properties, "tblW")),
+    indent: parseMeasure(firstChild(properties, "tblInd")),
+    alignment: valueOf(firstChild(properties, "jc")),
+    layout: parseTableLayout(firstChild(properties, "tblLayout")),
+    cellMargins: parseBoxMeasures(firstChild(properties, "tblCellMar"), "table cell margins"),
+    borders: parseTableBorders(firstChild(properties, "tblBorders"), context.idPrefix),
+    gridColumnWidthsPt: children(grid, "gridCol").map(
+      (column) => numberAttribute(column, "w", twipsToPt) ?? 0
+    ),
+    rows
+  });
+}
+function parseBoxMeasures(element, label) {
+  if (!element) return void 0;
+  assertAllowedAttributes(element, /* @__PURE__ */ new Set(), label);
+  const allowed = /* @__PURE__ */ new Set(["top", "right", "bottom", "left", "start", "end"]);
+  assertAllowedPropertyChildren(element, allowed, label);
+  assertUniqueChildNames(element, label);
+  if (firstChild(element, "left") && firstChild(element, "start") || firstChild(element, "right") && firstChild(element, "end")) {
+    throw new DocxImportError(
+      "unsupported_feature",
+      `${label} mixes physical and logical side aliases`,
+      label
+    );
+  }
+  const result = stripUndefined({
+    top: parseMeasure(firstChild(element, "top")),
+    right: parseMeasure(firstChild(element, "right")),
+    bottom: parseMeasure(firstChild(element, "bottom")),
+    left: parseMeasure(firstChild(element, "left")),
+    start: parseMeasure(firstChild(element, "start")),
+    end: parseMeasure(firstChild(element, "end"))
+  });
+  return Object.keys(result).length > 0 ? result : void 0;
+}
+function parseTableBorders(element, partName) {
+  if (!element) return void 0;
+  assertAllowedAttributes(element, /* @__PURE__ */ new Set(), "table borders");
+  assertAllowedPropertyChildren(
+    element,
+    /* @__PURE__ */ new Set(["top", "right", "bottom", "left", "insideH", "insideV"]),
+    "table borders"
+  );
+  assertUniqueChildNames(element, "table borders");
+  const parse = (name) => {
+    const border = firstChild(element, name);
+    if (!border) return void 0;
+    assertAllowedAttributes(
+      border,
+      /* @__PURE__ */ new Set(["val", "color", "sz", "space", "shadow", "frame"]),
+      "table border"
+    );
+    const style = valueOf(border);
+    if (!style)
+      throw new DocxImportError("invalid_package", "Table border lacks a style", partName);
+    return stripUndefined({
+      style,
+      color: attribute(border, "color"),
+      sizePt: numberAttribute(border, "sz", (value) => value / 8),
+      spacePt: numberAttribute(border, "space"),
+      shadow: optionalBooleanAttribute(border, "shadow"),
+      frame: optionalBooleanAttribute(border, "frame")
+    });
+  };
+  const result = stripUndefined({
+    top: parse("top"),
+    right: parse("right"),
+    bottom: parse("bottom"),
+    left: parse("left"),
+    insideHorizontal: parse("insideH"),
+    insideVertical: parse("insideV")
+  });
+  return Object.keys(result).length > 0 ? result : void 0;
+}
+function validateShading(element, partName) {
+  if (!element) return;
+  assertAllowedAttributes(element, /* @__PURE__ */ new Set(["val", "color", "fill"]), "table cell shading");
+  const pattern = valueOf(element);
+  const foreground = attribute(element, "color");
+  if (pattern !== void 0 && pattern !== "clear" && pattern !== "solid") {
+    throw new DocxImportError(
+      "unsupported_feature",
+      `Table shading pattern ${pattern} is not represented`,
+      partName
+    );
+  }
+  if (foreground !== void 0 && foreground.toLowerCase() !== "auto") {
+    throw new DocxImportError(
+      "unsupported_feature",
+      "Patterned table foreground colors are not represented",
+      partName
+    );
+  }
+}
+function parseTableLayout(element) {
+  if (!element) return void 0;
+  assertAllowedAttributes(element, /* @__PURE__ */ new Set(["type"]), "table layout");
+  const value = attribute(element, "type");
+  if (value === "fixed") return "fixed";
+  if (value === "autofit") return "autofit";
+  throw new DocxImportError(
+    "invalid_package",
+    `Invalid table layout type: ${String(value)}`,
+    "table layout"
+  );
+}
+function parseMeasure(element) {
+  if (!element) return void 0;
+  assertAllowedAttributes(element, /* @__PURE__ */ new Set(["w", "type"]), "OOXML measure");
+  const width = attribute(element, "w");
+  if (width === void 0)
+    throw new DocxImportError("invalid_package", "OOXML measure lacks a width");
+  const raw = Number(width);
+  if (!Number.isFinite(raw))
+    throw new DocxImportError("invalid_package", "OOXML measure width is invalid");
+  const type = attribute(element, "type") ?? "dxa";
+  if (type === "dxa") return { value: twipsToPt(raw), unit: "pt" };
+  if (type === "pct") return { value: raw / 50, unit: "percent" };
+  if (type === "auto" || type === "nil") return { value: raw, unit: "auto" };
+  throw new DocxImportError("unsupported_feature", `Unsupported OOXML measure type: ${type}`);
+}
+function parseStyles(root, limits) {
+  requireLocalName(root, "styles", "word/styles.xml");
+  requireWordNamespace(root, "word/styles.xml");
+  rejectUnsupportedContent(root, "word/styles.xml");
+  assertAllowedContentChildren(
+    root,
+    /* @__PURE__ */ new Set(["docDefaults", "latentStyles", "style"]),
+    "styles root"
+  );
+  const defaults = children(root, "docDefaults");
+  if (defaults.length > 1)
+    throw new DocxImportError("invalid_package", "Styles repeats docDefaults", "word/styles.xml");
+  if (defaults[0]) validateEmptyStyleDefaults(defaults[0]);
+  const styles = [];
+  const styleIds = /* @__PURE__ */ new Set();
+  for (const element of children(root, "style")) {
+    if (styles.length >= limits.maxStyles)
+      throw limitError("DOCX exceeds maxStyles", "word/styles.xml");
+    const styleId = requiredAttribute(element, "styleId", "word/styles.xml");
+    if (styleIds.has(styleId))
+      throw new DocxImportError("invalid_package", "Duplicate style id", "word/styles.xml");
+    styleIds.add(styleId);
+    const kind = attribute(element, "type") ?? "paragraph";
+    if (kind !== "paragraph" && kind !== "character") {
+      throw new DocxImportError(
+        "unsupported_feature",
+        `Style type ${kind} is not represented`,
+        "word/styles.xml"
+      );
+    }
+    assertAllowedAttributes(
+      element,
+      /* @__PURE__ */ new Set(["styleId", "type", "default", "customStyle"]),
+      "style"
+    );
+    assertAllowedPropertyChildren(
+      element,
+      /* @__PURE__ */ new Set([
+        "name",
+        "aliases",
+        "basedOn",
+        "next",
+        "link",
+        "uiPriority",
+        "semiHidden",
+        "unhideWhenUsed",
+        "qFormat",
+        "locked",
+        "personal",
+        "personalCompose",
+        "personalReply",
+        "rsid",
+        "pPr",
+        "rPr"
+      ]),
+      "style definition"
+    );
+    styles.push(
+      stripUndefined({
+        styleId,
+        kind,
+        name: valueOf(firstChild(element, "name")),
+        basedOn: valueOf(firstChild(element, "basedOn")),
+        next: valueOf(firstChild(element, "next")),
+        isDefault: booleanAttribute(element, "default", false),
+        paragraph: parseParagraphProperties(singletonChild(element, "pPr", "style definition")),
+        run: parseRunProperties(singletonChild(element, "rPr", "style definition"))
+      })
+    );
+  }
+  const styleById = new Map(styles.map((style) => [style.styleId, style]));
+  for (const style of styles) {
+    const seen = /* @__PURE__ */ new Set();
+    let current = style;
+    let depth = 0;
+    while (current?.basedOn !== void 0) {
+      if (!seen.add(current.styleId)) {
+        throw new DocxImportError(
+          "invalid_package",
+          "Style inheritance contains a cycle",
+          "word/styles.xml"
+        );
+      }
+      depth += 1;
+      if (depth > limits.maxStyleInheritanceDepth) {
+        throw limitError("DOCX exceeds maxStyleInheritanceDepth", "word/styles.xml");
+      }
+      current = styleById.get(current.basedOn);
+    }
+  }
+  return styles;
+}
+function validateEmptyStyleDefaults(defaults) {
+  assertAllowedPropertyChildren(defaults, /* @__PURE__ */ new Set(["pPrDefault", "rPrDefault"]), "style defaults");
+  for (const [wrapperName, propertyName, parse] of [
+    ["pPrDefault", "pPr", parseParagraphProperties],
+    ["rPrDefault", "rPr", parseRunProperties]
+  ]) {
+    const wrappers = children(defaults, wrapperName);
+    if (wrappers.length > 1)
+      throw new DocxImportError(
+        "invalid_package",
+        `Styles repeats ${wrapperName}`,
+        "word/styles.xml"
+      );
+    const wrapper = wrappers[0];
+    assertAllowedPropertyChildren(wrapper, /* @__PURE__ */ new Set([propertyName]), "style defaults");
+    const properties = singletonChild(wrapper, propertyName, "style defaults");
+    if (properties && Object.keys(parse(properties)).length > 0) {
+      throw new DocxImportError(
+        "unsupported_feature",
+        "Non-empty document style defaults are not yet represented",
+        "word/styles.xml"
+      );
+    }
+  }
+}
+function parseNumbering(root, limits) {
+  requireLocalName(root, "numbering", "word/numbering.xml");
+  requireWordNamespace(root, "word/numbering.xml");
+  rejectUnsupportedContent(root, "word/numbering.xml");
+  assertAllowedContentChildren(
+    root,
+    /* @__PURE__ */ new Set(["numPicBullet", "abstractNum", "num"]),
+    "numbering root"
+  );
+  if (children(root, "numPicBullet").length > 0) {
+    throw new DocxImportError(
+      "unsupported_feature",
+      "Picture bullets are not yet supported",
+      "word/numbering.xml"
+    );
+  }
+  const abstract = /* @__PURE__ */ new Map();
+  for (const definition of children(root, "abstractNum")) {
+    if (abstract.size >= limits.maxNumberingDefinitions) {
+      throw limitError("DOCX exceeds maxNumberingDefinitions", "word/numbering.xml");
+    }
+    const id = requiredAttribute(definition, "abstractNumId", "word/numbering.xml");
+    assertAllowedAttributes(
+      definition,
+      /* @__PURE__ */ new Set(["abstractNumId", "w15:restartNumberingAfterBreak"]),
+      "abstract numbering definition"
+    );
+    const restartAfterBreak = prefixedAttribute(definition, "w15", "restartNumberingAfterBreak");
+    if (restartAfterBreak !== void 0 && parseBooleanLexical(restartAfterBreak)) {
+      throw new DocxImportError(
+        "unsupported_feature",
+        "Restarting numbering after section breaks is not represented",
+        "word/numbering.xml"
+      );
+    }
+    assertAllowedPropertyChildren(
+      definition,
+      /* @__PURE__ */ new Set(["nsid", "multiLevelType", "tmpl", "name", "lvl"]),
+      "abstract numbering definition"
+    );
+    if (abstract.has(id))
+      throw new DocxImportError(
+        "invalid_package",
+        "Duplicate abstract numbering id",
+        "word/numbering.xml"
+      );
+    const levels = children(definition, "lvl").map(parseListLevel);
+    validateListLevels(levels, "abstract numbering definition");
+    abstract.set(id, levels);
+  }
+  const numIds = /* @__PURE__ */ new Set();
+  const nums = children(root, "num");
+  if (nums.length > limits.maxNumberingDefinitions) {
+    throw limitError("DOCX exceeds maxNumberingDefinitions", "word/numbering.xml");
+  }
+  return nums.map((numbering) => {
+    assertAllowedAttributes(numbering, /* @__PURE__ */ new Set(["numId"]), "numbering definition");
+    assertAllowedPropertyChildren(
+      numbering,
+      /* @__PURE__ */ new Set(["abstractNumId", "lvlOverride"]),
+      "numbering definition"
+    );
+    const numId = requiredAttribute(numbering, "numId", "word/numbering.xml");
+    if (numIds.has(numId))
+      throw new DocxImportError("invalid_package", "Duplicate numbering id", "word/numbering.xml");
+    numIds.add(numId);
+    const abstractNumId = valueOf(firstChild(numbering, "abstractNumId"));
+    if (!abstractNumId || !abstract.has(abstractNumId))
+      throw new DocxImportError(
+        "invalid_package",
+        "Numbering references a missing abstract definition",
+        "word/numbering.xml"
+      );
+    const overrides = children(numbering, "lvlOverride").map((override) => {
+      assertAllowedAttributes(override, /* @__PURE__ */ new Set(["ilvl"]), "numbering override");
+      assertAllowedPropertyChildren(
+        override,
+        /* @__PURE__ */ new Set(["startOverride", "lvl"]),
+        "numbering override"
+      );
+      return stripUndefined({
+        level: parseLevelIndex(override),
+        start: numberValue(firstChild(override, "startOverride")),
+        definition: firstChild(override, "lvl") ? parseListLevel(firstChild(override, "lvl")) : void 0
+      });
+    });
+    validateOverrideLevels(overrides);
+    return {
+      numId,
+      abstractNumId,
+      levels: (abstract.get(abstractNumId) ?? []).map((level) => ({ ...level })),
+      overrides
+    };
+  });
+}
+function parseListLevel(level) {
+  assertAllowedAttributes(level, /* @__PURE__ */ new Set(["ilvl", "tplc", "w15:tentative"]), "numbering level");
+  assertAllowedPropertyChildren(
+    level,
+    /* @__PURE__ */ new Set([
+      "start",
+      "numFmt",
+      "lvlRestart",
+      "pStyle",
+      "isLgl",
+      "suff",
+      "lvlText",
+      "lvlJc",
+      "pPr",
+      "rPr"
+    ]),
+    "numbering level"
+  );
+  assertUniqueChildNames(level, "numbering level");
+  for (const name of [
+    "start",
+    "numFmt",
+    "lvlRestart",
+    "pStyle",
+    "isLgl",
+    "suff",
+    "lvlText",
+    "lvlJc"
+  ]) {
+    assertAllowedAttributes(firstChild(level, name), /* @__PURE__ */ new Set(["val"]), `numbering level ${name}`);
+  }
+  const restartElement = firstChild(level, "lvlRestart");
+  const restart = restartElement ? integerValue(restartElement, 0) : void 0;
+  if (restart !== void 0 && (restart < 0 || restart > 9)) {
+    throw new DocxImportError(
+      "invalid_package",
+      "Numbering restart level must be from 0 through 9",
+      "word/numbering.xml"
+    );
+  }
+  return stripUndefined({
+    level: parseLevelIndex(level),
+    start: integerValue(firstChild(level, "start"), 1),
+    restart,
+    legal: optionalBoolean(firstChild(level, "isLgl")),
+    alignment: valueOf(firstChild(level, "lvlJc")),
+    format: valueOf(firstChild(level, "numFmt")),
+    text: valueOf(firstChild(level, "lvlText")),
+    suffix: valueOf(firstChild(level, "suff")),
+    paragraphStyleId: valueOf(firstChild(level, "pStyle")),
+    paragraph: parseParagraphProperties(singletonChild(level, "pPr", "numbering level")),
+    run: parseRunProperties(singletonChild(level, "rPr", "numbering level"))
+  });
+}
+function parseLevelIndex(element) {
+  const raw = requiredAttribute(element, "ilvl", "word/numbering.xml");
+  const level = Number(raw);
+  if (!Number.isInteger(level) || level < 0 || level > 8) {
+    throw new DocxImportError(
+      "invalid_package",
+      "Numbering level must be an integer from 0 through 8",
+      "word/numbering.xml"
+    );
+  }
+  return level;
+}
+function validateListLevels(levels, label) {
+  if (levels.length > 9)
+    throw new DocxImportError(
+      "invalid_package",
+      `${label} has more than nine levels`,
+      "word/numbering.xml"
+    );
+  const seen = /* @__PURE__ */ new Set();
+  for (const level of levels) {
+    if (seen.has(level.level))
+      throw new DocxImportError(
+        "invalid_package",
+        `${label} repeats a level`,
+        "word/numbering.xml"
+      );
+    seen.add(level.level);
+  }
+}
+function validateOverrideLevels(overrides) {
+  if (overrides.length > 9)
+    throw new DocxImportError(
+      "invalid_package",
+      "Numbering definition has more than nine overrides",
+      "word/numbering.xml"
+    );
+  const seen = /* @__PURE__ */ new Set();
+  for (const override of overrides) {
+    if (seen.has(override.level))
+      throw new DocxImportError(
+        "invalid_package",
+        "Numbering definition repeats an override",
+        "word/numbering.xml"
+      );
+    seen.add(override.level);
+    if (override.definition && override.definition.level !== override.level) {
+      throw new DocxImportError(
+        "invalid_package",
+        "Numbering override level disagrees with its definition",
+        "word/numbering.xml"
+      );
+    }
+  }
+}
+function parseParagraphProperties(element) {
+  assertAllowedPropertyChildren(
+    element,
+    /* @__PURE__ */ new Set([
+      "pStyle",
+      "jc",
+      "spacing",
+      "ind",
+      "keepNext",
+      "keepLines",
+      "pageBreakBefore",
+      "outlineLvl",
+      "bidi",
+      "numPr",
+      "sectPr"
+    ]),
+    "paragraph properties"
+  );
+  assertUniqueChildNames(element, "paragraph properties");
+  const spacing = firstChild(element, "spacing");
+  const indent = firstChild(element, "ind");
+  const numProperties = firstChild(element, "numPr");
+  assertAllowedPropertyChildren(
+    numProperties,
+    /* @__PURE__ */ new Set(["numId", "ilvl"]),
+    "paragraph numbering properties"
+  );
+  assertUniqueChildNames(numProperties, "paragraph numbering properties");
+  for (const name of [
+    "pStyle",
+    "jc",
+    "keepNext",
+    "keepLines",
+    "pageBreakBefore",
+    "outlineLvl",
+    "bidi"
+  ]) {
+    assertAllowedAttributes(firstChild(element, name), /* @__PURE__ */ new Set(["val"]), `paragraph ${name}`);
+  }
+  assertAllowedAttributes(
+    spacing,
+    /* @__PURE__ */ new Set(["before", "after", "line", "lineRule"]),
+    "paragraph spacing"
+  );
+  assertAllowedAttributes(
+    indent,
+    /* @__PURE__ */ new Set(["left", "right", "firstLine", "hanging"]),
+    "paragraph indentation"
+  );
+  assertAllowedAttributes(numProperties, /* @__PURE__ */ new Set(), "paragraph numbering properties");
+  assertAllowedAttributes(
+    firstChild(numProperties, "numId"),
+    /* @__PURE__ */ new Set(["val"]),
+    "paragraph numbering id"
+  );
+  assertAllowedAttributes(
+    firstChild(numProperties, "ilvl"),
+    /* @__PURE__ */ new Set(["val"]),
+    "paragraph numbering level"
+  );
+  if (attribute(indent, "firstLine") !== void 0 && attribute(indent, "hanging") !== void 0) {
+    throw new DocxImportError(
+      "invalid_package",
+      "Paragraph indentation cannot specify both firstLine and hanging",
+      "paragraph indentation"
+    );
+  }
+  const lineRule = attribute(spacing, "lineRule");
+  if (lineRule !== void 0 && lineRule !== "auto" && lineRule !== "exact" && lineRule !== "atLeast") {
+    throw new DocxImportError(
+      "invalid_package",
+      "Paragraph line rule is invalid",
+      "paragraph spacing"
+    );
+  }
+  const numId = valueOf(firstChild(numProperties, "numId"));
+  return stripUndefined({
+    alignment: valueOf(firstChild(element, "jc")),
+    spaceBeforePt: numberAttribute(spacing, "before", twipsToPt),
+    spaceAfterPt: numberAttribute(spacing, "after", twipsToPt),
+    line: numberAttribute(spacing, "line"),
+    lineRule,
+    indentLeftPt: numberAttribute(indent, "left", twipsToPt),
+    indentRightPt: numberAttribute(indent, "right", twipsToPt),
+    firstLinePt: numberAttribute(indent, "firstLine", twipsToPt),
+    hangingPt: numberAttribute(indent, "hanging", twipsToPt),
+    keepNext: optionalBoolean(firstChild(element, "keepNext")),
+    keepLines: optionalBoolean(firstChild(element, "keepLines")),
+    pageBreakBefore: optionalBoolean(firstChild(element, "pageBreakBefore")),
+    outlineLevel: numberValue(firstChild(element, "outlineLvl")),
+    bidirectional: optionalBoolean(firstChild(element, "bidi")),
+    list: numId === void 0 ? void 0 : { numId, level: integerValue(firstChild(numProperties, "ilvl"), 0) }
+  });
+}
+function parseRunProperties(element) {
+  assertAllowedPropertyChildren(
+    element,
+    /* @__PURE__ */ new Set([
+      "rStyle",
+      "rFonts",
+      "sz",
+      "szCs",
+      "color",
+      "b",
+      "bCs",
+      "i",
+      "iCs",
+      "u",
+      "strike",
+      "highlight",
+      "vertAlign",
+      "lang"
+    ]),
+    "run properties"
+  );
+  assertUniqueChildNames(element, "run properties");
+  const fonts = firstChild(element, "rFonts");
+  const color = firstChild(element, "color");
+  if (["asciiTheme", "hAnsiTheme", "eastAsiaTheme", "cstheme"].some(
+    (name) => attribute(fonts, name) !== void 0
+  )) {
+    throw new DocxImportError(
+      "unsupported_feature",
+      "Theme font references are not represented by the document model",
+      "run properties"
+    );
+  }
+  if (["themeColor", "themeTint", "themeShade"].some((name) => attribute(color, name) !== void 0)) {
+    throw new DocxImportError(
+      "unsupported_feature",
+      "Theme colors are not represented by the document model",
+      "run properties"
+    );
+  }
+  assertAllowedAttributes(fonts, /* @__PURE__ */ new Set(["ascii", "hAnsi", "eastAsia", "cs"]), "run fonts");
+  assertAllowedAttributes(color, /* @__PURE__ */ new Set(["val"]), "run color");
+  const underlineElement = firstChild(element, "u");
+  assertAllowedAttributes(underlineElement, /* @__PURE__ */ new Set(["val"]), "run underline");
+  for (const name of [
+    "rStyle",
+    "sz",
+    "szCs",
+    "b",
+    "bCs",
+    "i",
+    "iCs",
+    "strike",
+    "highlight",
+    "vertAlign",
+    "lang"
+  ]) {
+    assertAllowedAttributes(firstChild(element, name), /* @__PURE__ */ new Set(["val"]), `run ${name}`);
+  }
+  const underline = valueOf(underlineElement);
+  if (underline !== void 0 && underline !== "single" && underline !== "none") {
+    throw new DocxImportError(
+      "unsupported_feature",
+      `Underline style ${underline} is not represented by the document model`,
+      "run properties"
+    );
+  }
+  const directFonts = ["ascii", "hAnsi", "eastAsia", "cs"].map((name) => attribute(fonts, name)).filter((value) => value !== void 0);
+  if (new Set(directFonts).size > 1) {
+    throw new DocxImportError(
+      "unsupported_feature",
+      "Script-specific font families are not represented by the document model",
+      "run properties"
+    );
+  }
+  const colorValue = valueOf(color);
+  if (colorValue?.toLowerCase() === "auto") {
+    throw new DocxImportError(
+      "unsupported_feature",
+      "Automatic run colors are not represented by the document model",
+      "run properties"
+    );
+  }
+  return stripUndefined({
+    fontFamily: directFonts[0],
+    fontSizePt: numberValue(firstChild(element, "sz"), (value) => value / 2),
+    fontSizeComplexScriptPt: numberValue(firstChild(element, "szCs"), (value) => value / 2),
+    color: colorValue,
+    bold: optionalBoolean(firstChild(element, "b")),
+    boldComplexScript: optionalBoolean(firstChild(element, "bCs")),
+    italic: optionalBoolean(firstChild(element, "i")),
+    italicComplexScript: optionalBoolean(firstChild(element, "iCs")),
+    underline,
+    strike: optionalBoolean(firstChild(element, "strike")),
+    highlight: valueOf(firstChild(element, "highlight")),
+    verticalAlign: valueOf(firstChild(element, "vertAlign")),
+    language: attribute(firstChild(element, "lang"), "val")
+  });
+}
+function assertAllowedPropertyChildren(element, allowed, label) {
+  for (const child of elementChildren(element)) {
+    if (!allowed.has(child.localName)) {
+      throw new DocxImportError(
+        "unsupported_feature",
+        `Unsupported ${label}: ${child.name}`,
+        label
+      );
+    }
+  }
+}
+function assertAllowedContentChildren(element, allowed, label) {
+  for (const child of elementChildren(element)) {
+    if (!allowed.has(child.localName) && !NON_CONTENT_MARKERS.has(child.localName)) {
+      throw new DocxImportError(
+        "unsupported_feature",
+        `Unsupported ${label} content: ${child.name}`,
+        label
+      );
+    }
+  }
+}
+function assertAllowedAttributes(element, allowed, label) {
+  if (!element) return;
+  for (const name of element.attributes.keys()) {
+    if (name === "xmlns" || name.startsWith("xmlns:")) continue;
+    const permitted = allowed.has(name) || name.startsWith("w:") && allowed.has(name.slice(2));
+    if (!permitted) {
+      throw new DocxImportError(
+        "unsupported_feature",
+        `Unsupported ${label} attribute: ${name}`,
+        label
+      );
+    }
+  }
+}
+function parseSection(element, startBlockIndex, endBlockIndex, relationships) {
+  assertAllowedAttributes(element, /* @__PURE__ */ new Set(["rsidR", "rsidRPr", "rsidSect"]), "section properties");
+  assertAllowedPropertyChildren(
+    element,
+    /* @__PURE__ */ new Set([
+      "headerReference",
+      "footerReference",
+      "type",
+      "pgSz",
+      "pgMar",
+      "pgNumType",
+      "titlePg",
+      "docGrid"
+    ]),
+    "section properties"
+  );
+  for (const singleton of ["type", "pgSz", "pgMar", "pgNumType", "titlePg", "docGrid"]) {
+    if (children(element, singleton).length > 1) {
+      throw new DocxImportError(
+        "invalid_package",
+        `Section repeats ${singleton}`,
+        "word/document.xml"
+      );
+    }
+  }
+  const pageSize = firstChild(element, "pgSz");
+  const margins = firstChild(element, "pgMar");
+  assertAllowedAttributes(pageSize, /* @__PURE__ */ new Set(["w", "h", "orient", "code"]), "section page size");
+  assertAllowedAttributes(
+    margins,
+    /* @__PURE__ */ new Set(["top", "right", "bottom", "left", "header", "footer", "gutter"]),
+    "section page margins"
+  );
+  assertAllowedContentChildren(pageSize, /* @__PURE__ */ new Set(), "section page size");
+  assertAllowedContentChildren(margins, /* @__PURE__ */ new Set(), "section page margins");
+  if (pageSize && (attribute(pageSize, "w") === void 0 || attribute(pageSize, "h") === void 0)) {
+    throw new DocxImportError(
+      "invalid_package",
+      "Section page size is incomplete",
+      "word/document.xml"
+    );
+  }
+  if (margins && ["top", "right", "bottom", "left", "header", "footer", "gutter"].some(
+    (name) => attribute(margins, name) === void 0
+  )) {
+    throw new DocxImportError(
+      "invalid_package",
+      "Section page margins are incomplete",
+      "word/document.xml"
+    );
+  }
+  const pageNumbering = firstChild(element, "pgNumType");
+  assertAllowedAttributes(pageNumbering, /* @__PURE__ */ new Set(), "section page numbering");
+  assertAllowedContentChildren(pageNumbering, /* @__PURE__ */ new Set(), "section page numbering");
+  const documentGrid = firstChild(element, "docGrid");
+  assertAllowedAttributes(
+    documentGrid,
+    /* @__PURE__ */ new Set(["type", "linePitch", "charSpace"]),
+    "section document grid"
+  );
+  assertAllowedContentChildren(documentGrid, /* @__PURE__ */ new Set(), "section document grid");
+  const gridType = attribute(documentGrid, "type");
+  if (gridType !== void 0 && gridType !== "default") {
+    throw new DocxImportError(
+      "unsupported_feature",
+      `Document grid type ${gridType} is not represented`,
+      "word/document.xml"
+    );
+  }
+  numberAttribute(documentGrid, "linePitch");
+  numberAttribute(documentGrid, "charSpace");
+  const sectionTypeElement = firstChild(element, "type");
+  const titlePageElement = firstChild(element, "titlePg");
+  assertAllowedAttributes(sectionTypeElement, /* @__PURE__ */ new Set(["val"]), "section break type");
+  assertAllowedAttributes(titlePageElement, /* @__PURE__ */ new Set(["val"]), "section title-page setting");
+  assertAllowedContentChildren(sectionTypeElement, /* @__PURE__ */ new Set(), "section break type");
+  assertAllowedContentChildren(titlePageElement, /* @__PURE__ */ new Set(), "section title-page setting");
+  const orientation = attribute(pageSize, "orient");
+  if (orientation !== void 0 && orientation !== "portrait" && orientation !== "landscape") {
+    throw new DocxImportError(
+      "invalid_package",
+      "Section page orientation is invalid",
+      "word/document.xml"
+    );
+  }
+  const sectionType = valueOf(sectionTypeElement);
+  if (sectionType !== void 0 && !(/* @__PURE__ */ new Set(["nextPage", "nextColumn", "continuous", "evenPage", "oddPage"])).has(sectionType)) {
+    throw new DocxImportError(
+      "invalid_package",
+      "Section break type is invalid",
+      "word/document.xml"
+    );
+  }
+  const references = (kind) => children(element, `${kind}Reference`).map((reference) => {
+    assertAllowedAttributes(reference, /* @__PURE__ */ new Set(["r:id", "type"]), `${kind} reference`);
+    assertAllowedContentChildren(reference, /* @__PURE__ */ new Set(), `${kind} reference`);
+    const relationshipId = requiredPrefixedAttribute(reference, "r", "id", "word/document.xml");
+    const relationship = relationships.get(relationshipId);
+    if (!relationship || relationship.type !== `${WORD_RELATIONSHIP_BASE}${kind}`) {
+      throw new DocxImportError(
+        "invalid_package",
+        `Section references a missing ${kind}`,
+        "word/document.xml"
+      );
+    }
+    const referenceKind = attribute(reference, "type") ?? "default";
+    if (referenceKind !== "default" && referenceKind !== "first" && referenceKind !== "even") {
+      throw new DocxImportError(
+        "invalid_package",
+        `Invalid ${kind} reference kind`,
+        "word/document.xml"
+      );
+    }
+    return {
+      kind: referenceKind,
+      relationshipId,
+      partName: relationship.partName
+    };
+  });
+  const headers = references("header");
+  const footers = references("footer");
+  for (const storyReferences of [headers, footers]) {
+    const kinds = /* @__PURE__ */ new Set();
+    for (const reference of storyReferences) {
+      if (kinds.has(reference.kind))
+        throw new DocxImportError(
+          "invalid_package",
+          "Section repeats a header/footer reference kind",
+          "word/document.xml"
+        );
+      kinds.add(reference.kind);
+    }
+  }
+  return stripUndefined({
+    startBlockIndex,
+    endBlockIndex,
+    type: sectionType,
+    titlePage: booleanValue(titlePageElement, false),
+    page: {
+      widthPt: numberAttribute(pageSize, "w", twipsToPt) ?? 612,
+      heightPt: numberAttribute(pageSize, "h", twipsToPt) ?? 792,
+      ...orientation !== void 0 ? { orientation } : {},
+      marginTopPt: numberAttribute(margins, "top", twipsToPt) ?? 72,
+      marginRightPt: numberAttribute(margins, "right", twipsToPt) ?? 72,
+      marginBottomPt: numberAttribute(margins, "bottom", twipsToPt) ?? 72,
+      marginLeftPt: numberAttribute(margins, "left", twipsToPt) ?? 72,
+      headerPt: numberAttribute(margins, "header", twipsToPt) ?? 36,
+      footerPt: numberAttribute(margins, "footer", twipsToPt) ?? 36,
+      gutterPt: numberAttribute(margins, "gutter", twipsToPt) ?? 0
+    },
+    headers,
+    footers
+  });
+}
+function defaultSection(startBlockIndex, endBlockIndex) {
+  return {
+    startBlockIndex,
+    endBlockIndex,
+    titlePage: false,
+    page: {
+      widthPt: 612,
+      heightPt: 792,
+      marginTopPt: 72,
+      marginRightPt: 72,
+      marginBottomPt: 72,
+      marginLeftPt: 72,
+      headerPt: 36,
+      footerPt: 36,
+      gutterPt: 0
+    },
+    headers: [],
+    footers: []
+  };
+}
+function resolveSectionStoryInheritance(sections) {
+  for (let index = 1; index < sections.length; index += 1) {
+    const previous = sections[index - 1];
+    const current = sections[index];
+    if (!previous || !current) continue;
+    for (const key of ["headers", "footers"]) {
+      const present = new Set(current[key].map((reference) => reference.kind));
+      for (const inherited of previous[key]) {
+        if (!present.has(inherited.kind)) current[key].push({ ...inherited });
+      }
+    }
+  }
+}
+function validateProjectedStories(sections, headers, footers, maximumBlocks, maximumCharacters) {
+  const costByPart = /* @__PURE__ */ new Map();
+  for (const story of [...headers, ...footers]) {
+    costByPart.set(story.partName, measureBlockTree(story.blocks));
+  }
+  let projectedBlocks = 0;
+  let projectedCharacters = 0;
+  for (const section of sections) {
+    for (const reference of [...section.headers, ...section.footers]) {
+      const storyCost = costByPart.get(reference.partName);
+      if (storyCost === void 0) {
+        throw new DocxImportError(
+          "invalid_package",
+          "Section references an unparsed header or footer",
+          reference.partName
+        );
+      }
+      projectedBlocks += storyCost.blocks;
+      projectedCharacters += storyCost.characters;
+      if (projectedBlocks > maximumBlocks)
+        throw limitError("DOCX exceeds maxProjectedStoryBlocks", reference.partName);
+      if (projectedCharacters > maximumCharacters) {
+        throw limitError("DOCX exceeds maxProjectedStoryCharacters", reference.partName);
+      }
+    }
+  }
+}
+function measureBlockTree(blocks) {
+  let count = 0;
+  let characters = 0;
+  const stack = [...blocks];
+  while (stack.length > 0) {
+    const block = stack.pop();
+    if (!block) continue;
+    count += 1;
+    if (block.kind === "paragraph") {
+      for (const inline of block.inlines)
+        if (inline.kind === "run") characters += inline.text.length;
+    } else if (block.kind === "table") {
+      for (const row of block.rows)
+        for (const cell of row.cells) {
+          for (const child of cell.blocks) stack.push(child);
+        }
+    }
+  }
+  return { blocks: count, characters };
+}
+function parseCommentsExtended(root, maximum) {
+  requireLocalName(root, "commentsEx", "word/commentsExtended.xml");
+  requirePrefixedNamespaceTree(
+    root,
+    "w15",
+    COMMENTS_EXTENDED_NAMESPACE,
+    "word/commentsExtended.xml"
+  );
+  const result = /* @__PURE__ */ new Map();
+  for (const comment of elementChildren(root)) {
+    if (comment.localName !== "commentEx")
+      throw unsupportedElement(comment, "word/commentsExtended.xml");
+    if (result.size >= maximum)
+      throw limitError("DOCX exceeds maxComments", "word/commentsExtended.xml");
+    const paragraphId = requiredPrefixedAttribute(
+      comment,
+      "w15",
+      "paraId",
+      "word/commentsExtended.xml"
+    );
+    if (result.has(paragraphId))
+      throw new DocxImportError(
+        "invalid_package",
+        "Duplicate extended comment paragraph id",
+        "word/commentsExtended.xml"
+      );
+    const parentParagraphId = prefixedAttribute(comment, "w15", "paraIdParent");
+    const done = prefixedAttribute(comment, "w15", "done");
+    result.set(paragraphId, {
+      ...parentParagraphId !== void 0 ? { parentParagraphId } : {},
+      ...done !== void 0 ? { resolved: !FALSE_VALUES.has(done.toLowerCase()) } : {}
+    });
+  }
+  return result;
+}
+function parseComments(root, context, extended, maximum) {
+  requireLocalName(root, "comments", "word/comments.xml");
+  rejectUnsupportedContent(root, "word/comments.xml");
+  requireWordNamespace(root, "word/comments.xml");
+  const drafts = [];
+  for (const comment of elementChildren(root)) {
+    if (comment.localName !== "comment") throw unsupportedElement(comment, "word/comments.xml");
+    if (drafts.length >= maximum) throw limitError("DOCX exceeds maxComments", "word/comments.xml");
+    const lastParagraph = lastDescendant(comment, "p");
+    const paragraphId = prefixedAttribute(lastParagraph, "w14", "paraId");
+    drafts.push({
+      // commentsExtended keys a comment by the paraId of its final paragraph.
+      ...paragraphId !== void 0 ? { paragraphId } : {},
+      comment: stripUndefined({
+        id: requiredAttribute(comment, "id", "word/comments.xml"),
+        author: attribute(comment, "author"),
+        initials: attribute(comment, "initials"),
+        createdAt: attribute(comment, "date"),
+        blocks: parseBlockContainer(comment, context)
+      })
+    });
+  }
+  const commentIdByParagraphId = /* @__PURE__ */ new Map();
+  const commentIds = /* @__PURE__ */ new Set();
+  for (const draft of drafts) {
+    if (commentIds.has(draft.comment.id))
+      throw new DocxImportError("invalid_package", "Duplicate comment id", "word/comments.xml");
+    commentIds.add(draft.comment.id);
+    if (!draft.paragraphId) continue;
+    if (commentIdByParagraphId.has(draft.paragraphId)) {
+      throw new DocxImportError(
+        "invalid_package",
+        "Duplicate comment paragraph id",
+        "word/comments.xml"
+      );
+    }
+    commentIdByParagraphId.set(draft.paragraphId, draft.comment.id);
+  }
+  for (const draft of drafts) {
+    if (!draft.paragraphId) continue;
+    const metadata = extended.get(draft.paragraphId);
+    if (!metadata) continue;
+    if (metadata.resolved !== void 0) draft.comment.resolved = metadata.resolved;
+    if (metadata.parentParagraphId !== void 0) {
+      const parentId = commentIdByParagraphId.get(metadata.parentParagraphId);
+      if (!parentId)
+        throw new DocxImportError(
+          "invalid_package",
+          "Comment reply references a missing parent",
+          "word/commentsExtended.xml"
+        );
+      draft.comment.parentId = parentId;
+    }
+  }
+  for (const paragraphId of extended.keys()) {
+    if (!commentIdByParagraphId.has(paragraphId)) {
+      throw new DocxImportError(
+        "invalid_package",
+        "Extended comment references a missing comment paragraph",
+        "word/commentsExtended.xml"
+      );
+    }
+  }
+  return drafts.map((draft) => draft.comment);
+}
+function validateCommentReferences(blocks, headers, footers, comments) {
+  const ids = new Set(comments.map((comment) => comment.id));
+  const commentById = new Map(comments.map((comment) => [comment.id, comment]));
+  const roots = new Set(
+    comments.filter((comment) => comment.parentId === void 0).map((comment) => comment.id)
+  );
+  for (const comment of comments) {
+    if (comment.parentId !== void 0 && !ids.has(comment.parentId)) {
+      throw new DocxImportError(
+        "invalid_package",
+        "Comment reply references a missing parent",
+        "word/commentsExtended.xml"
+      );
+    }
+  }
+  const visitState = /* @__PURE__ */ new Map();
+  for (const comment of comments) {
+    if (visitState.get(comment.id) === 2) continue;
+    const path = [];
+    let current = comment;
+    while (current && visitState.get(current.id) === void 0) {
+      visitState.set(current.id, 1);
+      path.push(current.id);
+      current = current.parentId === void 0 ? void 0 : commentById.get(current.parentId);
+    }
+    if (current && visitState.get(current.id) === 1) {
+      throw new DocxImportError(
+        "invalid_package",
+        "Comment reply graph contains a cycle",
+        "word/commentsExtended.xml"
+      );
+    }
+    for (const id of path) visitState.set(id, 2);
+  }
+  const storyCountsByComment = /* @__PURE__ */ new Map();
+  const countStory = (items) => {
+    const counts = /* @__PURE__ */ new Map();
+    const walk = (nested) => {
+      for (const block of nested) {
+        if (block.kind === "paragraph") {
+          for (const anchor of block.commentAnchors) {
+            if (!ids.has(anchor.commentId))
+              throw new DocxImportError(
+                "invalid_package",
+                "Document references a missing comment",
+                "word/comments.xml"
+              );
+            if (!roots.has(anchor.commentId))
+              throw new DocxImportError(
+                "invalid_package",
+                "Document anchors a comment reply instead of its root",
+                "word/comments.xml"
+              );
+            const count = counts.get(anchor.commentId) ?? { start: 0, end: 0, reference: 0 };
+            count[anchor.kind] += 1;
+            counts.set(anchor.commentId, count);
+          }
+        } else if (block.kind === "table") {
+          for (const row of block.rows) for (const cell of row.cells) walk(cell.blocks);
+        }
+      }
+    };
+    walk(items);
+    for (const [commentId, count] of counts) {
+      const stories = storyCountsByComment.get(commentId);
+      if (stories) stories.push(count);
+      else storyCountsByComment.set(commentId, [count]);
+    }
+  };
+  countStory(blocks);
+  for (const item of [...headers, ...footers]) countStory(item.blocks);
+  for (const comment of comments) {
+    const anchoredStories = storyCountsByComment.get(comment.id) ?? [];
+    if (comment.parentId === void 0) {
+      if (anchoredStories.length !== 1) {
+        throw new DocxImportError(
+          "invalid_package",
+          "Root comment must be anchored in exactly one document story",
+          "word/document.xml"
+        );
+      }
+      const count = anchoredStories[0];
+      if (count.reference !== 1 || count.start > 1 || count.end > 1) {
+        throw new DocxImportError(
+          "invalid_package",
+          "Comment story has duplicate or missing reference anchors",
+          "word/document.xml"
+        );
+      }
+    } else if (anchoredStories.length > 0) {
+      throw new DocxImportError(
+        "invalid_package",
+        "Comment replies must not have document anchors",
+        "word/document.xml"
+      );
+    }
+  }
+}
+var UNSUPPORTED_CONTENT = /* @__PURE__ */ new Map([
+  ["drawing", "drawings and images"],
+  ["pict", "VML drawings and images"],
+  ["object", "embedded objects"],
+  ["oleObject", "OLE objects"],
+  ["altChunk", "altChunk content"],
+  ["hyperlink", "hyperlinks"],
+  ["fldSimple", "fields"],
+  ["fldChar", "fields"],
+  ["instrText", "fields"],
+  ["footnoteReference", "footnotes"],
+  ["endnoteReference", "endnotes"],
+  ["sdt", "content controls"],
+  ["customXml", "custom XML content"],
+  ["smartTag", "smart tags"],
+  ["oMath", "equations"],
+  ["oMathPara", "equations"],
+  ["sym", "symbol-font characters"],
+  ["ruby", "ruby annotations"],
+  ["subDoc", "subdocuments"],
+  ["txbxContent", "text boxes"],
+  ["AlternateContent", "alternate content"],
+  ["moveFrom", "tracked moves"],
+  ["moveTo", "tracked moves"],
+  ["pPrChange", "paragraph-property revisions"],
+  ["rPrChange", "run-property revisions"],
+  ["tblPrChange", "table-property revisions"],
+  ["tblGridChange", "table-grid revisions"],
+  ["trPrChange", "table-row-property revisions"],
+  ["tcPrChange", "table-cell-property revisions"],
+  ["sectPrChange", "section-property revisions"],
+  ["numberingChange", "numbering-property revisions"],
+  ["cellIns", "table-cell insertion revisions"],
+  ["cellDel", "table-cell deletion revisions"],
+  ["cellMerge", "table-cell merge revisions"],
+  ["background", "document backgrounds"]
+]);
+function rejectUnsupportedContent(root, partName) {
+  const stack = [root];
+  while (stack.length > 0) {
+    const element = stack.pop();
+    if (!element) break;
+    const feature = UNSUPPORTED_CONTENT.get(element.localName);
+    if (feature)
+      throw new DocxImportError(
+        "unsupported_feature",
+        `DOCX ${feature} are not yet supported`,
+        partName
+      );
+    for (const child of elementChildren(element)) stack.push(child);
+  }
+}
+var NON_CONTENT_MARKERS = /* @__PURE__ */ new Set([
+  "bookmarkStart",
+  "bookmarkEnd",
+  "proofErr",
+  "permStart",
+  "permEnd",
+  "commentReference",
+  "lastRenderedPageBreak"
+]);
+function unsupportedElement(element, partName) {
+  return new DocxImportError(
+    "unsupported_feature",
+    `Unsupported content element: ${element.name}`,
+    partName
+  );
+}
+function relationshipSourcePart(relationshipPart) {
+  if (relationshipPart === "_rels/.rels") return "";
+  const match = /^(.*\/)?_rels\/([^/]+)\.rels$/.exec(relationshipPart);
+  if (!match)
+    throw new DocxImportError(
+      "invalid_package",
+      "Invalid relationships part name",
+      relationshipPart
+    );
+  return `${match[1] ?? ""}${match[2] ?? ""}`;
+}
+function resolvePartTarget(sourcePart, target, relationshipsPart) {
+  if (/[\u0000-\u001f\u007f]/.test(target) || target.includes("\\") || target.startsWith("//") || /%(?:2e|2f|5c)/i.test(target)) {
+    throw new DocxImportError("invalid_package", "Unsafe relationship target", relationshipsPart);
+  }
+  const packageAbsolute = target.startsWith("/");
+  const relativeTarget = packageAbsolute ? target.slice(1) : target;
+  const base = !packageAbsolute && sourcePart.includes("/") ? sourcePart.slice(0, sourcePart.lastIndexOf("/") + 1) : "";
+  const combined = `${base}${relativeTarget}`;
+  if (combined.includes("//"))
+    throw new DocxImportError(
+      "invalid_package",
+      "Relationship target contains an empty path segment",
+      relationshipsPart
+    );
+  let segmentCount = 1;
+  for (let index = 0; index < combined.length; index += 1) {
+    if (combined.charCodeAt(index) === 47) {
+      segmentCount += 1;
+      if (segmentCount > 256)
+        throw limitError(
+          "Relationship target exceeds its path-segment safety cap",
+          relationshipsPart
+        );
+    }
+  }
+  const output = [];
+  for (const segment of combined.split("/")) {
+    if (segment === "")
+      throw new DocxImportError(
+        "invalid_package",
+        "Relationship target contains an empty path segment",
+        relationshipsPart
+      );
+    if (segment === ".") continue;
+    if (segment === "..") {
+      if (output.length === 0)
+        throw new DocxImportError(
+          "invalid_package",
+          "Relationship target escapes the package root",
+          relationshipsPart
+        );
+      output.pop();
+    } else output.push(segment);
+  }
+  return output.join("/");
+}
+function consumeBlock(budget) {
+  budget.blocks += 1;
+  if (budget.blocks > budget.limits.maxBlocks) throw limitError("DOCX exceeds maxBlocks");
+}
+function consumeText(budget, characters) {
+  budget.textCharacters += characters;
+  if (budget.textCharacters > budget.limits.maxTextCharacters)
+    throw limitError("DOCX exceeds maxTextCharacters");
+}
+function elementChildren(element) {
+  return element?.children.filter((child) => child.type === "element") ?? [];
+}
+function children(element, name) {
+  return elementChildren(element).filter((child) => child.localName === name);
+}
+function firstChild(element, name) {
+  return elementChildren(element).find((child) => child.localName === name);
+}
+function singletonChild(element, name, label) {
+  let match;
+  for (const child of elementChildren(element)) {
+    if (child.localName !== name) continue;
+    if (match) throw new DocxImportError("invalid_package", `${label} repeats ${name}`);
+    match = child;
+  }
+  return match;
+}
+function assertUniqueChildNames(element, label) {
+  const seen = /* @__PURE__ */ new Set();
+  for (const child of elementChildren(element)) {
+    if (seen.has(child.localName)) {
+      throw new DocxImportError("invalid_package", `${label} repeats ${child.localName}`);
+    }
+    seen.add(child.localName);
+  }
+}
+function lastDescendant(element, name) {
+  let match;
+  const stack = [element];
+  while (stack.length > 0) {
+    const current = stack.pop();
+    if (!current) continue;
+    if (current.localName === name) match = current;
+    const nested = elementChildren(current);
+    for (let index = nested.length - 1; index >= 0; index -= 1) {
+      const child = nested[index];
+      if (child) stack.push(child);
+    }
+  }
+  return match;
+}
+function onlyElement(element, name, partName) {
+  const matches = children(element, name);
+  if (matches.length !== 1)
+    throw new DocxImportError("invalid_package", `Expected exactly one ${name} element`, partName);
+  return matches[0];
+}
+function attribute(element, name) {
+  return prefixedAttribute(element, "w", name);
+}
+function requiredAttribute(element, name, partName) {
+  const value = attribute(element, name);
+  if (value === void 0 || value === "")
+    throw new DocxImportError("invalid_package", `Missing required ${name} attribute`, partName);
+  return value;
+}
+function prefixedAttribute(element, prefix, name) {
+  return element?.attributes.get(`${prefix}:${name}`);
+}
+function requiredPrefixedAttribute(element, prefix, name, partName) {
+  const value = prefixedAttribute(element, prefix, name);
+  if (value === void 0 || value === "") {
+    throw new DocxImportError(
+      "invalid_package",
+      `Missing required ${prefix}:${name} attribute`,
+      partName
+    );
+  }
+  return value;
+}
+function exactAttribute(element, name) {
+  return element?.attributes.get(name);
+}
+function requiredExactAttribute(element, name, partName) {
+  const value = exactAttribute(element, name);
+  if (value === void 0 || value === "")
+    throw new DocxImportError("invalid_package", `Missing required ${name} attribute`, partName);
+  return value;
+}
+function assertExactAttributes(element, allowed, partName) {
+  for (const name of element.attributes.keys()) {
+    if (name === "xmlns" || name.startsWith("xmlns:")) continue;
+    if (!allowed.has(name))
+      throw new DocxImportError("invalid_package", `Unexpected attribute: ${name}`, partName);
+  }
+}
+function requireLeafElement(element, partName) {
+  for (const child of element.children) {
+    if (child.type === "element" || !isOnlyXmlWhitespace(child.value)) {
+      throw new DocxImportError(
+        "invalid_package",
+        "Package declaration element must be empty",
+        partName
+      );
+    }
+  }
+}
+function textContent(element) {
+  let output = "";
+  const stack = [...element.children].reverse();
+  while (stack.length > 0) {
+    const node = stack.pop();
+    if (!node) break;
+    if (node.type === "text") output += node.value;
+    else {
+      for (let index = node.children.length - 1; index >= 0; index -= 1) {
+        const child = node.children[index];
+        if (child) stack.push(child);
+      }
+    }
+  }
+  return output;
+}
+function requireLocalName(element, expected, partName) {
+  if (element.localName !== expected)
+    throw new DocxImportError("invalid_package", `Expected ${expected} root element`, partName);
+}
+function requireDefaultNamespace(element, expected, partName) {
+  if (element.attributes.get("xmlns") !== expected) {
+    throw new DocxImportError(
+      "invalid_package",
+      "Unexpected or missing XML default namespace",
+      partName
+    );
+  }
+}
+function requireDefaultNamespaceTree(root, expected, partName) {
+  requireDefaultNamespace(root, expected, partName);
+  const stack = [root];
+  while (stack.length > 0) {
+    const element = stack.pop();
+    if (!element) break;
+    if (element.name.includes(":"))
+      throw new DocxImportError(
+        "invalid_package",
+        `Prefixed element is forbidden in this package part: ${element.name}`,
+        partName
+      );
+    const rebound = element.attributes.get("xmlns");
+    if (rebound !== void 0 && rebound !== expected)
+      throw new DocxImportError("invalid_package", "Default XML namespace is rebound", partName);
+    for (const child of elementChildren(element)) stack.push(child);
+  }
+}
+function requirePrefixedNamespace(element, prefix, expected, partName) {
+  if (element.attributes.get(`xmlns:${prefix}`) !== expected) {
+    throw new DocxImportError(
+      "unsupported_feature",
+      `Unsupported ${prefix} XML namespace`,
+      partName
+    );
+  }
+}
+function requireWordNamespace(root, partName) {
+  requirePrefixedNamespaceTree(root, "w", WORDPROCESSINGML_NAMESPACE, partName);
+}
+function requirePrefixedNamespaceTree(root, prefix, expected, partName) {
+  requirePrefixedNamespace(root, prefix, expected, partName);
+  validateKnownNamespaceBindings(root, partName);
+  const stack = [root];
+  while (stack.length > 0) {
+    const element = stack.pop();
+    if (!element) break;
+    if (!element.name.startsWith(`${prefix}:`)) {
+      throw new DocxImportError(
+        "unsupported_feature",
+        `Unsupported namespaced Word content: ${element.name}`,
+        partName
+      );
+    }
+    const rebound = element.attributes.get(`xmlns:${prefix}`);
+    if (rebound !== void 0 && rebound !== expected) {
+      throw new DocxImportError("invalid_package", `${prefix} XML namespace is rebound`, partName);
+    }
+    for (const child of elementChildren(element)) stack.push(child);
+  }
+}
+var KNOWN_XML_NAMESPACES = /* @__PURE__ */ new Map([
+  ["xml", "http://www.w3.org/XML/1998/namespace"],
+  ["w", WORDPROCESSINGML_NAMESPACE],
+  ["r", "http://schemas.openxmlformats.org/officeDocument/2006/relationships"],
+  ["w14", "http://schemas.microsoft.com/office/word/2010/wordml"],
+  ["w15", COMMENTS_EXTENDED_NAMESPACE]
+]);
+function validateNamespaceWellFormedness(root, partName) {
+  const xmlNamespace = KNOWN_XML_NAMESPACES.get("xml");
+  const bindings = /* @__PURE__ */ new Map([["xml", xmlNamespace]]);
+  const visit = (element) => {
+    const changes = [];
+    const defaultNamespace = element.attributes.get("xmlns");
+    if (defaultNamespace === xmlNamespace || defaultNamespace === "http://www.w3.org/2000/xmlns/") {
+      throw new DocxImportError(
+        "invalid_xml",
+        "Default namespace uses a reserved XML namespace",
+        partName
+      );
+    }
+    for (const [name, value] of element.attributes) {
+      if (!name.startsWith("xmlns:")) continue;
+      const prefix = name.slice(6);
+      if (prefix === "xmlns" || value.length === 0 || value === "http://www.w3.org/2000/xmlns/") {
+        throw new DocxImportError("invalid_xml", "Invalid XML namespace declaration", partName);
+      }
+      if (prefix === "xml" !== (value === xmlNamespace)) {
+        throw new DocxImportError("invalid_xml", "The xml namespace is reserved", partName);
+      }
+      const previous = bindings.get(prefix);
+      changes.push(stripUndefined({ prefix, previous }));
+      bindings.set(prefix, value);
+    }
+    const elementSeparator = element.name.indexOf(":");
+    if (elementSeparator >= 0 && !bindings.has(element.name.slice(0, elementSeparator))) {
+      throw new DocxImportError(
+        "invalid_xml",
+        "Element uses an undeclared namespace prefix",
+        partName
+      );
+    }
+    for (const name of element.attributes.keys()) {
+      if (name === "xmlns" || name.startsWith("xmlns:")) continue;
+      const separator = name.indexOf(":");
+      if (separator >= 0 && !bindings.has(name.slice(0, separator))) {
+        throw new DocxImportError(
+          "invalid_xml",
+          "Attribute uses an undeclared namespace prefix",
+          partName
+        );
+      }
+    }
+    for (const child of elementChildren(element)) visit(child);
+    for (let index = changes.length - 1; index >= 0; index -= 1) {
+      const change = changes[index];
+      if (!change) continue;
+      if (change.previous === void 0) bindings.delete(change.prefix);
+      else bindings.set(change.prefix, change.previous);
+    }
+  };
+  visit(root);
+}
+function validateKnownNamespaceBindings(root, partName) {
+  const bindings = /* @__PURE__ */ new Map([["xml", KNOWN_XML_NAMESPACES.get("xml")]]);
+  const visit = (element) => {
+    const changes = [];
+    for (const [name, value] of element.attributes) {
+      if (!name.startsWith("xmlns:")) continue;
+      const declaredPrefix = name.slice(6);
+      const previous = bindings.get(declaredPrefix);
+      changes.push(stripUndefined({ prefix: declaredPrefix, previous }));
+      const expected = KNOWN_XML_NAMESPACES.get(declaredPrefix);
+      if (expected !== void 0 && value !== expected) {
+        throw new DocxImportError(
+          "invalid_package",
+          `Known namespace ${declaredPrefix} is rebound`,
+          partName
+        );
+      }
+      bindings.set(declaredPrefix, value);
+    }
+    for (const name of element.attributes.keys()) {
+      if (name === "xmlns" || name.startsWith("xmlns:")) continue;
+      const separator = name.indexOf(":");
+      if (separator < 0) continue;
+      const attributePrefix = name.slice(0, separator);
+      const expected = KNOWN_XML_NAMESPACES.get(attributePrefix);
+      if (!bindings.has(attributePrefix)) {
+        throw new DocxImportError(
+          "invalid_package",
+          `Attribute uses an unbound ${attributePrefix} namespace`,
+          partName
+        );
+      }
+      if (expected !== void 0 && bindings.get(attributePrefix) !== expected) {
+        throw new DocxImportError(
+          "invalid_package",
+          `Attribute uses an unbound ${attributePrefix} namespace`,
+          partName
+        );
+      }
+    }
+    for (const child of elementChildren(element)) visit(child);
+    for (let index = changes.length - 1; index >= 0; index -= 1) {
+      const change = changes[index];
+      if (!change) continue;
+      if (change.previous === void 0) bindings.delete(change.prefix);
+      else bindings.set(change.prefix, change.previous);
+    }
+  };
+  visit(root);
+}
+function valueOf(element) {
+  return attribute(element, "val");
+}
+function numberValue(element, transform = (value) => value) {
+  const value = valueOf(element);
+  if (value === void 0) return void 0;
+  const number = Number(value);
+  if (!Number.isFinite(number))
+    throw new DocxImportError("invalid_package", "OOXML numeric value is invalid");
+  const transformed = transform(number);
+  if (!Number.isFinite(transformed))
+    throw new DocxImportError("invalid_package", "OOXML numeric value is out of range");
+  return transformed;
+}
+function integerValue(element, fallback) {
+  if (valueOf(element) === void 0) return fallback;
+  const value = numberValue(element);
+  if (value === void 0 || !Number.isInteger(value)) {
+    throw new DocxImportError("invalid_package", "OOXML integer value is invalid");
+  }
+  return value;
+}
+function numberAttribute(element, name, transform = (value) => value) {
+  const raw = attribute(element, name);
+  if (raw === void 0) return void 0;
+  const value = Number(raw);
+  if (!Number.isFinite(value))
+    throw new DocxImportError("invalid_package", "OOXML numeric attribute is invalid");
+  const transformed = transform(value);
+  if (!Number.isFinite(transformed))
+    throw new DocxImportError("invalid_package", "OOXML numeric attribute is out of range");
+  return transformed;
+}
+function booleanAttribute(element, name, fallback) {
+  const value = attribute(element, name);
+  return value === void 0 ? fallback : parseBooleanLexical(value);
+}
+function optionalBooleanAttribute(element, name) {
+  const value = attribute(element, name);
+  return value === void 0 ? void 0 : parseBooleanLexical(value);
+}
+function optionalBoolean(element) {
+  if (!element) return void 0;
+  return booleanValue(element, true);
+}
+function booleanValue(element, fallback) {
+  if (!element) return fallback;
+  const value = valueOf(element);
+  return value === void 0 ? true : parseBooleanLexical(value);
+}
+var FALSE_VALUES = /* @__PURE__ */ new Set(["0", "false", "off", "no"]);
+var TRUE_VALUES = /* @__PURE__ */ new Set(["1", "true", "on", "yes"]);
+function parseBooleanLexical(value) {
+  const normalized = value.toLowerCase();
+  if (FALSE_VALUES.has(normalized)) return false;
+  if (TRUE_VALUES.has(normalized)) return true;
+  throw new DocxImportError("invalid_package", "OOXML boolean value is invalid");
+}
+function localName(name) {
+  return name.slice(name.lastIndexOf(":") + 1);
+}
+function twipsToPt(value) {
+  return value / 20;
+}
+function stripUndefined(value) {
+  const record = value;
+  for (const key of Object.keys(record)) if (record[key] === void 0) delete record[key];
+  return value;
+}
+function decodeUtf8(bytes, description, partName) {
+  try {
+    return new TextDecoder("utf-8", { fatal: true }).decode(bytes);
+  } catch {
+    throw new DocxImportError(
+      partName ? "invalid_xml" : "invalid_zip",
+      `${description} is not valid UTF-8`,
+      partName
+    );
+  }
+}
+function limitError(message, partName) {
+  return new DocxImportError("limit_exceeded", message, partName);
+}
+function compareStrings(left, right) {
+  return left < right ? -1 : left > right ? 1 : 0;
+}
+function compareOpaqueRelationships(left, right) {
+  return compareStrings(left.sourcePart, right.sourcePart) || compareStrings(left.type, right.type) || compareStrings(left.targetPart, right.targetPart);
+}
+function compareOpaqueContentTypes(left, right) {
+  return compareStrings(left.partName, right.partName) || compareStrings(left.contentType, right.contentType);
+}
+
+// src/document-docx-codec.ts
+var importedStyleCache = /* @__PURE__ */ new WeakMap();
+async function exportDocx(document, options = {}) {
+  validateExportOptions(options);
+  document.toJSON();
+  const envelope = DOCUMENT_LOSS_PRESERVATION.get(document);
+  if (envelope && await documentModelDigest(document) === envelope.modelDigest) {
+    return FileBlob.fromBytes(envelope.sourceBytes.slice(), {
+      type: DOCX_MEDIA_TYPE,
+      ...options.fileName ? { name: options.fileName } : {}
+    });
+  }
+  const blockingIssues = documentFidelityReport(document).filter(
+    (issue) => issue.severity === "error"
+  );
+  if (blockingIssues.length > 0 && options.unsupportedContent !== "discard") {
+    throw new DocumentFidelityError(
+      'DOCX export would discard opaque OOXML; export again with unsupportedContent: "discard" only after explicit user acknowledgement',
+      blockingIssues
+    );
+  }
+  const docx = await import("docx");
+  const context = buildDocxContext(document, docx);
+  const evenAndOddHeaderAndFooters = document.evenAndOddHeaders;
+  const sections = document.sections.items.map((section, index) => {
+    const end = document.sections.items[index + 1]?.startBlockIndex ?? document.blocks.items.length;
+    const blocks = document.blocks.items.slice(section.startBlockIndex, end);
+    const landscape = section.page.widthPt > section.page.heightPt;
+    return {
+      properties: {
+        page: {
+          size: {
+            width: ptToTwip(landscape ? section.page.heightPt : section.page.widthPt),
+            height: ptToTwip(landscape ? section.page.widthPt : section.page.heightPt),
+            orientation: landscape ? docx.PageOrientation.LANDSCAPE : docx.PageOrientation.PORTRAIT
+          },
+          margin: {
+            top: ptToTwip(section.page.marginTopPt),
+            right: ptToTwip(section.page.marginRightPt),
+            bottom: ptToTwip(section.page.marginBottomPt),
+            left: ptToTwip(section.page.marginLeftPt),
+            header: ptToTwip(section.page.headerPt ?? 36),
+            footer: ptToTwip(section.page.footerPt ?? 36),
+            gutter: ptToTwip(section.page.gutterPt ?? 0)
+          }
+        },
+        titlePage: section.titlePage
+      },
+      headers: buildDocxStories(section.headers, section.page, docx, context),
+      footers: buildDocxStories(section.footers, section.page, docx, context),
+      children: blocks.map((block) => toDocxBlock(block, section.page, docx, context))
+    };
+  });
+  const file = new docx.Document({
+    sections,
+    numbering: { config: numberingConfig(docx) },
+    comments: { children: context.commentDefinitions },
+    features: { trackRevisions: document.trackRevisions },
+    evenAndOddHeaderAndFooters,
+    creator: "OpenGeni",
+    lastModifiedBy: "OpenGeni",
+    revision: document.revision
+  });
+  const bytes = await packDocxWithBoundedCompression(file, docx.Packer, [
+    {
+      path: "docProps/core.xml",
+      data: deterministicCoreProperties(document.revision)
+    }
+  ]);
+  return FileBlob.fromBytes(bytes, {
+    type: DOCX_MEDIA_TYPE,
+    ...options.fileName ? { name: options.fileName } : {}
+  });
+}
+async function importDocx2(input, options = {}) {
+  validateImportOptions(options);
+  const sourceBytes = await ownedDocxBytes(input);
+  const imported = await importDocx(ownedArrayBuffer(sourceBytes), options.limits);
+  if (hasOpaqueContent(imported.opaqueContent) && options.unsupportedContent === "error") {
+    throw new DocumentFidelityError(
+      "The DOCX contains bounded inert OOXML outside the editable document model",
+      [opaqueContentIssue(imported.opaqueContent, "error")]
+    );
+  }
+  const document = documentFromImportedDocx(imported, await semanticNamespace(imported));
+  if (hasOpaqueContent(imported.opaqueContent)) {
+    DOCUMENT_LOSS_PRESERVATION.set(document, {
+      sourceBytes,
+      sourceDigest: await sha256Hex(sourceBytes),
+      importedRevision: document.revision,
+      opaqueContent: cloneOpaqueContent(imported.opaqueContent),
+      modelDigest: await documentModelDigest(document)
+    });
+  }
+  return document;
+}
+function fidelityReport(document) {
+  document.toJSON();
+  return documentFidelityReport(document);
+}
+function lossPreservationEnvelope(document) {
+  document.toJSON();
+  return documentLossPreservationEnvelope(document);
+}
+async function attachLossPreservationEnvelope(document, envelope, options = {}) {
+  document.toJSON();
+  validateAttachOptions(options);
+  const normalized = normalizeLossPreservationEnvelope(envelope);
+  if (normalized.sourceDigest !== await sha256Hex(normalized.sourceBytes)) {
+    throw new DocxImportError(
+      "invalid_package",
+      "DOCX loss-preservation source digest does not match its bytes"
+    );
+  }
+  const imported = await importDocx(ownedArrayBuffer(normalized.sourceBytes), options.limits);
+  if (!sameOpaqueContent(imported.opaqueContent, normalized.opaqueContent)) {
+    throw new DocxImportError(
+      "invalid_package",
+      "DOCX loss-preservation metadata does not match its source package"
+    );
+  }
+  const projected = documentFromImportedDocx(imported, await semanticNamespace(imported));
+  const projectedDigest = await documentModelDigest(projected);
+  const documentDigest = await documentModelDigest(document);
+  if (projectedDigest !== normalized.modelDigest || documentDigest !== normalized.modelDigest) {
+    throw new DocxImportError(
+      "invalid_package",
+      "DOCX loss-preservation envelope belongs to a different document snapshot"
+    );
+  }
+  DOCUMENT_LOSS_PRESERVATION.set(document, {
+    sourceBytes: normalized.sourceBytes,
+    sourceDigest: normalized.sourceDigest,
+    importedRevision: document.revision,
+    opaqueContent: normalized.opaqueContent,
+    modelDigest: normalized.modelDigest
+  });
+}
+function documentFromImportedDocx(imported, idNamespace) {
+  if (imported.schemaVersion !== 1 || imported.format !== "docx") {
+    throw new UnsupportedArtifactFeatureError(
+      "document",
+      "unknown imported DOCX schema",
+      "DOCX import"
+    );
+  }
+  const importedSections = [...imported.sections].sort(
+    (left, right) => left.startBlockIndex - right.startBlockIndex
+  );
+  validateImportedSections(imported, importedSections);
+  const firstSection = importedSections[0];
+  if (!firstSection || firstSection.startBlockIndex !== 0)
+    throw new Error("Imported DOCX has no section starting at body block 0");
+  const document = Document.create({
+    page: importedPage(firstSection),
+    idNamespace,
+    titlePage: firstSection.titlePage,
+    evenAndOddHeaders: imported.evenAndOddHeaders,
+    trackRevisions: imported.trackRevisions
+  });
+  const paragraphMap = /* @__PURE__ */ new Map();
+  const styleMap = new Map(imported.styles.map((style) => [style.styleId, style]));
+  const listKinds = importedListKinds(imported.lists);
+  let sectionIndex = 1;
+  imported.blocks.forEach((block, blockIndex) => {
+    while (importedSections[sectionIndex]?.startBlockIndex === blockIndex) {
+      document.sections.add({
+        page: importedPage(importedSections[sectionIndex]),
+        titlePage: importedSections[sectionIndex].titlePage
+      });
+      sectionIndex += 1;
+    }
+    appendImportedBodyBlock(document, block, styleMap, listKinds, paragraphMap);
+  });
+  while (sectionIndex < importedSections.length) {
+    const section = importedSections[sectionIndex];
+    if (section.startBlockIndex !== imported.blocks.length)
+      throw new Error("Imported DOCX section boundary does not align with body blocks");
+    if (document.sections.items.at(-1)?.startBlockIndex === imported.blocks.length) {
+      throw new UnsupportedArtifactFeatureError(
+        "document",
+        "multiple empty sections at the same boundary",
+        "DOCX import"
+      );
+    }
+    document.sections.add({ page: importedPage(section), titlePage: section.titlePage });
+    sectionIndex += 1;
+  }
+  const headers = new Map(imported.headers.map((story) => [story.partName, story]));
+  const footers = new Map(imported.footers.map((story) => [story.partName, story]));
+  importedSections.forEach((source, index) => {
+    const target = document.sections.items[index];
+    if (!target) throw new Error("Imported DOCX section count changed during conversion");
+    importSectionStories(
+      document,
+      source,
+      target,
+      headers,
+      footers,
+      styleMap,
+      listKinds,
+      paragraphMap
+    );
+  });
+  importComments(document, imported.comments, paragraphMap, styleMap);
+  importTrackedChanges(document, imported, paragraphMap);
+  validateImportedReviewProjection(document);
+  document.toJSON();
+  return document;
+}
+function appendImportedBodyBlock(document, block, styles, listKinds, paragraphs) {
+  if (block.kind === "pageBreak") {
+    document.blocks.addPageBreak();
+    return;
+  }
+  if (block.kind === "paragraph") {
+    if (isOnlyPageBreak(block, styles)) {
+      document.blocks.addPageBreak();
+      return;
+    }
+    const projected2 = importedParagraph(block, styles, listKinds);
+    const paragraph = document.blocks.addParagraph(projected2.runs, projected2.style);
+    appendMap(paragraphs, block.id, { source: block, target: paragraph });
+    return;
+  }
+  const projected = importedTable(
+    block,
+    styles,
+    listKinds,
+    document.sections.items.at(-1)?.page ?? document.page
+  );
+  document.blocks.addTable(projected.rows, projected.style);
+}
+function appendImportedStoryBlock(story, block, document, styles, listKinds, paragraphs, page) {
+  if (block.kind === "pageBreak" || block.kind === "paragraph" && block.inlines.some((inline) => inline.kind === "pageBreak")) {
+    throw new UnsupportedArtifactFeatureError(
+      "document",
+      "page breaks in headers or footers",
+      "DOCX import"
+    );
+  }
+  if (block.kind === "paragraph") {
+    const projected = importedParagraph(block, styles, listKinds);
+    const paragraph = story.addParagraph(projected.runs, projected.style);
+    appendMap(paragraphs, block.id, { source: block, target: paragraph });
+  } else {
+    const projected = importedTable(block, styles, listKinds, page);
+    story.addTable(projected.rows, projected.style);
+  }
+}
+function importedParagraph(source, styles, listKinds) {
+  if (source.inlines.some((inline) => inline.kind === "pageBreak")) {
+    throw new UnsupportedArtifactFeatureError(
+      "document",
+      "inline page breaks mixed with paragraph text",
+      "DOCX import"
+    );
+  }
+  const inherited = resolveImportedStyle(source.styleId, styles, "paragraph");
+  const paragraphStyle = mapImportedParagraphStyle(
+    { ...inherited.paragraph, ...source.style },
+    source.styleId,
+    listKinds
+  );
+  const runs = source.inlines.map((inline) => {
+    if (inline.kind !== "run") throw new Error("Unexpected non-run in imported paragraph");
+    const inheritedRun = resolveImportedStyle(inline.styleId, styles, "character").run;
+    return new DocumentTextRun(
+      inline.text,
+      mapImportedRunStyle({ ...inherited.run, ...inheritedRun, ...inline.style })
+    );
+  });
+  return { runs: runs.length > 0 ? runs : "", style: paragraphStyle };
+}
+function importedTable(source, styles, listKinds, page) {
+  if (source.rows.length === 0 || source.rows.some((row) => row.cells.length === 0))
+    throw new Error("Imported DOCX table is empty");
+  if (source.styleId) {
+    throw new UnsupportedArtifactFeatureError(
+      "document",
+      `table style ${source.styleId}`,
+      "DOCX import"
+    );
+  }
+  const columnCount = source.rows[0].cells.length;
+  if (source.rows.some((row) => row.cells.length !== columnCount)) {
+    throw new UnsupportedArtifactFeatureError("document", "ragged DOCX tables", "DOCX import");
+  }
+  const headerRows = source.rows.findIndex((row) => !row.header);
+  const normalizedHeaderRows = headerRows < 0 ? source.rows.length : headerRows;
+  if (source.rows.slice(normalizedHeaderRows).some((row) => row.header)) {
+    throw new UnsupportedArtifactFeatureError(
+      "document",
+      "non-contiguous repeating table headers",
+      "DOCX import"
+    );
+  }
+  const cannotSplit = source.rows[0].cannotSplit;
+  if (source.rows.some((row) => row.cannotSplit !== cannotSplit)) {
+    throw new UnsupportedArtifactFeatureError(
+      "document",
+      "mixed table row-splitting policies",
+      "DOCX import"
+    );
+  }
+  if (source.rows.some((row) => row.heightPt !== void 0 || row.heightRule !== void 0)) {
+    throw new UnsupportedArtifactFeatureError(
+      "document",
+      "explicit table row heights",
+      "DOCX import"
+    );
+  }
+  let headerFill;
+  let filledHeaderCells = 0;
+  let unfilledHeaderCells = 0;
+  const rows = source.rows.map(
+    (row, rowIndex) => row.cells.map((cell, columnIndex) => {
+      if (cell.columnSpan !== 1 || cell.verticalMerge !== void 0) {
+        throw new UnsupportedArtifactFeatureError(
+          "document",
+          "merged DOCX table cells",
+          "DOCX import"
+        );
+      }
+      if (cell.verticalAlignment !== "center") {
+        throw new UnsupportedArtifactFeatureError(
+          "document",
+          `table cell vertical alignment ${cell.verticalAlignment ?? "default"}`,
+          "DOCX import"
+        );
+      }
+      if (cell.blocks.length !== 1 || cell.blocks[0]?.kind !== "paragraph") {
+        throw new UnsupportedArtifactFeatureError(
+          "document",
+          "multi-paragraph or nested DOCX table cells",
+          "DOCX import"
+        );
+      }
+      const explicitFill = cell.fill && cell.fill.toLowerCase() !== "auto" ? normalizeHex(cell.fill) : void 0;
+      if (explicitFill) {
+        if (rowIndex >= normalizedHeaderRows) {
+          throw new UnsupportedArtifactFeatureError("document", "body cell shading", "DOCX import");
+        }
+        if (headerFill && headerFill !== explicitFill) {
+          throw new UnsupportedArtifactFeatureError(
+            "document",
+            "mixed table-header fills",
+            "DOCX import"
+          );
+        }
+        headerFill = explicitFill;
+        filledHeaderCells += 1;
+      } else if (rowIndex < normalizedHeaderRows) {
+        unfilledHeaderCells += 1;
+      }
+      const paragraph = cell.blocks[0];
+      if (paragraph.inlines.some((inline) => inline.kind === "pageBreak") || paragraph.commentAnchors.length > 0) {
+        throw new UnsupportedArtifactFeatureError(
+          "document",
+          "page breaks or comments in table cells",
+          "DOCX import"
+        );
+      }
+      const inherited = resolveImportedStyle(paragraph.styleId, styles, "paragraph");
+      assertRepresentableTableCellParagraph(
+        { ...inherited.paragraph, ...paragraph.style },
+        paragraph.styleId,
+        listKinds
+      );
+      if (cell.width) {
+        const expected = source.gridColumnWidthsPt[columnIndex];
+        if (cell.width.unit !== "pt" || expected === void 0 || Math.abs(cell.width.value - expected) > 0.05) {
+          throw new UnsupportedArtifactFeatureError(
+            "document",
+            "table cell widths inconsistent with the fixed column grid",
+            "DOCX import"
+          );
+        }
+      }
+      return paragraph.inlines.map((inline) => {
+        if (inline.kind !== "run") throw new Error("Unexpected non-run in imported table cell");
+        if (inline.changeId)
+          throw new UnsupportedArtifactFeatureError(
+            "document",
+            "tracked changes in table cells",
+            "DOCX import"
+          );
+        const runStyle = resolveImportedStyle(inline.styleId, styles, "character").run;
+        return new DocumentTextRun(
+          inline.text,
+          mapImportedRunStyle({ ...inherited.run, ...runStyle, ...inline.style })
+        );
+      });
+    })
+  );
+  if (filledHeaderCells > 0 && unfilledHeaderCells > 0) {
+    throw new UnsupportedArtifactFeatureError(
+      "document",
+      "partially shaded table-header rows",
+      "DOCX import"
+    );
+  }
+  const usable = page.widthPt - page.marginLeftPt - page.marginRightPt;
+  if (source.gridColumnWidthsPt.length > 0 && (source.gridColumnWidthsPt.length !== columnCount || source.gridColumnWidthsPt.some((width) => !Number.isFinite(width) || width <= 0))) {
+    throw new UnsupportedArtifactFeatureError(
+      "document",
+      "invalid or incomplete fixed table column grid",
+      "DOCX import"
+    );
+  }
+  const widths = source.gridColumnWidthsPt.length === columnCount ? source.gridColumnWidthsPt : void 0;
+  const widthPt = source.width?.unit === "pt" ? source.width.value : widths?.reduce((total, width) => total + width, 0) ?? usable;
+  if (source.width && source.width.unit !== "pt" && source.width.unit !== "auto") {
+    throw new UnsupportedArtifactFeatureError(
+      "document",
+      "percentage-width DOCX tables",
+      "DOCX import"
+    );
+  }
+  if (source.width?.unit === "pt" && widths && Math.abs(source.width.value - widths.reduce((total, width) => total + width, 0)) > 0.05) {
+    throw new UnsupportedArtifactFeatureError(
+      "document",
+      "table width inconsistent with its fixed column grid",
+      "DOCX import"
+    );
+  }
+  if (source.alignment && source.alignment !== "left" && source.alignment !== "start") {
+    throw new UnsupportedArtifactFeatureError(
+      "document",
+      `table alignment ${source.alignment}`,
+      "DOCX import"
+    );
+  }
+  if (source.layout !== "fixed") {
+    throw new UnsupportedArtifactFeatureError("document", "autofit DOCX tables", "DOCX import");
+  }
+  const cellPaddingPt = importedUniformCellPadding(source);
+  const borderColor = importedUniformTableBorder(source.borders);
+  if (!source.indent || source.indent.unit !== "pt" || Math.abs(source.indent.value - cellPaddingPt) > 0.01) {
+    throw new UnsupportedArtifactFeatureError(
+      "document",
+      "table indent not equal to its leading cell padding",
+      "DOCX import"
+    );
+  }
+  return {
+    rows,
+    style: {
+      widthPt,
+      ...widths ? { columnWidthsPt: [...widths] } : {},
+      headerRows: normalizedHeaderRows,
+      cellPaddingPt,
+      borderColor,
+      ...headerFill ? { headerFill } : {},
+      ...!cannotSplit ? { allowRowSplit: true } : {}
+    }
+  };
+}
+function importSectionStories(document, source, target, headers, footers, styles, listKinds, paragraphs) {
+  const apply = (references, available, stories) => {
+    for (const reference of references) {
+      const key = reference.kind === "default" ? "default" : reference.kind === "first" ? "first" : reference.kind === "even" ? "even" : void 0;
+      if (!key)
+        throw new UnsupportedArtifactFeatureError(
+          "document",
+          `header/footer variant ${reference.kind}`,
+          "DOCX import"
+        );
+      const importedStory = available.get(reference.partName);
+      if (!importedStory)
+        throw new Error(`Imported DOCX references missing story ${reference.partName}`);
+      const story = stories[key];
+      if (story.items.length > 0)
+        throw new Error(`Imported DOCX repeats ${key} header/footer for one section`);
+      if (isEmptyStoryPlaceholder(importedStory)) continue;
+      for (const block of importedStory.blocks)
+        appendImportedStoryBlock(
+          story,
+          block,
+          document,
+          styles,
+          listKinds,
+          paragraphs,
+          target.page
+        );
+    }
+  };
+  apply(source.headers, headers, target.headers);
+  apply(source.footers, footers, target.footers);
+}
+function isEmptyStoryPlaceholder(story) {
+  const block = story.blocks[0];
+  return story.blocks.length === 1 && block?.kind === "paragraph" && block.styleId === void 0 && Object.keys(block.style).length === 0 && block.commentAnchors.length === 0 && block.inlines.every(
+    (inline) => inline.kind === "run" && inline.text.length === 0 && inline.styleId === void 0 && Object.keys(inline.style).length === 0
+  );
+}
+function importComments(document, comments, paragraphs, styles) {
+  const byId = new Map(comments.map((comment) => [comment.id, comment]));
+  const roots = [];
+  const repliesByParent = /* @__PURE__ */ new Map();
+  for (const raw of comments) {
+    const comment = raw;
+    if (comment.parentId === void 0) roots.push(comment);
+    else appendMap(repliesByParent, comment.parentId, comment);
+  }
+  const anchorsByComment = /* @__PURE__ */ new Map();
+  for (const projections of paragraphs.values()) {
+    for (const { source, target } of projections) {
+      const anchors = /* @__PURE__ */ new Map();
+      for (const anchor of source.commentAnchors) appendMap(anchors, anchor.commentId, anchor);
+      for (const [commentId, values] of anchors) {
+        const start = values.find((anchor) => anchor.kind === "start")?.textOffset ?? values.find((anchor) => anchor.kind === "reference")?.textOffset;
+        const end = values.find((anchor) => anchor.kind === "end")?.textOffset ?? start;
+        if (start === void 0 || end === void 0) {
+          throw new Error(`Imported comment ${commentId} has an incomplete anchor`);
+        }
+        appendMap(anchorsByComment, commentId, { source, target, start, end });
+      }
+    }
+  }
+  for (const root of roots) {
+    const matches = anchorsByComment.get(root.id) ?? [];
+    const sourceIds = new Set(matches.map((match) => match.source.id));
+    if (matches.length === 0 || sourceIds.size !== 1)
+      throw new Error(`Imported comment ${root.id} must have exactly one source text anchor`);
+    if (matches.length > 1) {
+      throw new UnsupportedArtifactFeatureError(
+        "document",
+        "comments in shared or inherited header/footer stories",
+        "DOCX import"
+      );
+    }
+    const rootText = importedCommentText(root, styles);
+    assertRepresentableCommentInitials(root.author ?? "Unknown", root.initials);
+    const replies = repliesByParent.get(root.id) ?? [];
+    for (const match of matches) {
+      const thread = document.comments.addThread(
+        { block: match.target, start: match.start, end: match.end },
+        rootText,
+        {
+          author: root.author ?? "Unknown",
+          createdAt: normalizedImportedDate(root.createdAt),
+          resolved: root.resolved ?? false
+        }
+      );
+      for (const reply of replies) {
+        assertRepresentableCommentInitials(reply.author ?? "Unknown", reply.initials);
+        thread.addReply(
+          importedCommentText(reply, styles),
+          reply.author ?? "Unknown",
+          normalizedImportedDate(reply.createdAt)
+        );
+      }
+    }
+    byId.delete(root.id);
+    for (const reply of replies) byId.delete(reply.id);
+  }
+  if (byId.size > 0)
+    throw new Error(`Imported DOCX has orphaned comment replies: ${[...byId.keys()].join(", ")}`);
+}
+function importTrackedChanges(document, imported, paragraphs) {
+  for (const source of imported.trackedChanges) {
+    const projections = paragraphs.get(source.blockId);
+    if (!projections || projections.length === 0)
+      throw new UnsupportedArtifactFeatureError(
+        "document",
+        "tracked changes outside body/header/footer paragraphs",
+        "DOCX import"
+      );
+    if (projections.length > 1) {
+      throw new UnsupportedArtifactFeatureError(
+        "document",
+        "tracked changes in shared or inherited header/footer stories",
+        "DOCX import"
+      );
+    }
+    const extended = source;
+    for (const paragraph of projections) {
+      const start = extended.startTextOffset ?? inlineIndexToTextOffset(paragraph.source, source.startInlineIndex);
+      const end = extended.endTextOffset ?? inlineIndexToTextOffset(paragraph.source, source.endInlineIndex);
+      document.changes.add(
+        { block: paragraph.target, start, end },
+        source.kind,
+        source.author ?? "Unknown",
+        normalizedImportedDate(source.createdAt)
+      );
+    }
+  }
+}
+function validateImportedReviewProjection(document) {
+  const commentsByBlock = /* @__PURE__ */ new Map();
+  for (const comment of document.comments.items) {
+    appendMap(commentsByBlock, comment.blockId, comment);
+  }
+  const changesByBlock = /* @__PURE__ */ new Map();
+  for (const change of document.changes.items) {
+    appendMap(changesByBlock, change.blockId, change);
+  }
+  for (const block of document.allStoryBlocks()) {
+    if (!(block instanceof DocumentParagraph)) continue;
+    const comments = commentsByBlock.get(block.id) ?? [];
+    const changes = changesByBlock.get(block.id) ?? [];
+    validateNonCrossingComments(comments);
+    validateNonOverlappingChanges(changes);
+    validateReviewMarkupForDocx(block, comments, changes);
+  }
+}
+function resolveImportedStyle(styleId, styles, expectedKind, seen = /* @__PURE__ */ new Set(), applyDefault = true) {
+  const cacheKey = `${expectedKind}:${applyDefault ? "default" : "direct"}:${styleId ?? ""}`;
+  const cache = importedStyleCache.get(styles) ?? /* @__PURE__ */ new Map();
+  if (!importedStyleCache.has(styles)) importedStyleCache.set(styles, cache);
+  if (seen.size === 0) {
+    const cached = cache.get(cacheKey);
+    if (cached) return cached;
+  }
+  if (!styleId) {
+    if (!applyDefault) {
+      const empty = { paragraph: {}, run: {} };
+      if (seen.size === 0) cache.set(cacheKey, empty);
+      return empty;
+    }
+    const defaults = [...styles.values()].filter(
+      (style2) => style2.isDefault && style2.kind === expectedKind
+    );
+    if (defaults.length > 1) {
+      throw new Error(`Imported DOCX defines multiple default ${expectedKind} styles`);
+    }
+    const defaultStyle = defaults[0];
+    const resolved2 = defaultStyle ? resolveImportedStyle(defaultStyle.styleId, styles, expectedKind, seen, false) : { paragraph: {}, run: {} };
+    if (seen.size === 0) cache.set(cacheKey, resolved2);
+    return resolved2;
+  }
+  if (seen.has(styleId)) throw new Error(`Imported DOCX style cycle at ${styleId}`);
+  const style = styles.get(styleId);
+  if (!style) {
+    if (["Normal", "DefaultParagraphFont", "ListParagraph"].includes(styleId)) {
+      return { paragraph: {}, run: {} };
+    }
+    throw new Error(`Imported DOCX references missing style ${styleId}`);
+  }
+  if (style.kind !== expectedKind) {
+    throw new UnsupportedArtifactFeatureError(
+      "document",
+      `${expectedKind} content using ${style.kind} style ${styleId}`,
+      "DOCX import"
+    );
+  }
+  const canonical = expectedKind === "paragraph" ? styleId === "Normal" || styleId === "ListParagraph" || /^(?:Heading\s*)[1-6]$/iu.test(styleId) : styleId === "DefaultParagraphFont";
+  if (!canonical) {
+    throw new UnsupportedArtifactFeatureError(
+      "document",
+      `custom named ${expectedKind} style ${styleId}`,
+      "DOCX import"
+    );
+  }
+  seen.add(styleId);
+  const parent = resolveImportedStyle(style.basedOn, styles, expectedKind, seen, false);
+  seen.delete(styleId);
+  const resolved = {
+    paragraph: { ...parent.paragraph, ...style.paragraph },
+    run: { ...parent.run, ...style.run }
+  };
+  if (seen.size === 0) cache.set(cacheKey, resolved);
+  return resolved;
+}
+function mapImportedParagraphStyle(style, styleId, listKinds) {
+  if (style.bidirectional)
+    throw new UnsupportedArtifactFeatureError(
+      "document",
+      "bidirectional paragraphs",
+      "DOCX import"
+    );
+  if ((style.indentLeftPt ?? 0) !== 0 || (style.indentRightPt ?? 0) !== 0 || (style.firstLinePt ?? 0) !== 0 || (style.hangingPt ?? 0) !== 0) {
+    throw new UnsupportedArtifactFeatureError(
+      "document",
+      "direct paragraph indentation",
+      "DOCX import"
+    );
+  }
+  if (style.keepLines)
+    throw new UnsupportedArtifactFeatureError(
+      "document",
+      "keep-lines paragraph pagination",
+      "DOCX import"
+    );
+  if (style.lineRule && style.lineRule !== "auto")
+    throw new UnsupportedArtifactFeatureError(
+      "document",
+      `paragraph line rule ${style.lineRule}`,
+      "DOCX import"
+    );
+  const headingMatch = /(?:^|\s)heading\s*([1-6])$/iu.exec(styleId ?? "");
+  const importedHeadingLevel = headingMatch ? Number(headingMatch[1]) : void 0;
+  if (style.outlineLevel !== void 0 && (style.outlineLevel < 0 || style.outlineLevel > 5 || importedHeadingLevel === void 0 || style.outlineLevel + 1 !== importedHeadingLevel)) {
+    throw new UnsupportedArtifactFeatureError(
+      "document",
+      `outline level ${style.outlineLevel} without the matching supported heading style`,
+      "DOCX import"
+    );
+  }
+  const alignmentValue = style.alignment === "both" ? "justify" : style.alignment === "center" ? "center" : style.alignment === "right" || style.alignment === "end" ? "right" : style.alignment === "left" || style.alignment === "start" ? "left" : void 0;
+  if (style.alignment && !alignmentValue)
+    throw new UnsupportedArtifactFeatureError(
+      "document",
+      `paragraph alignment ${style.alignment}`,
+      "DOCX import"
+    );
+  const list = style.list;
+  const listKind = list ? listKinds.get(list.numId)?.get(list.level) : void 0;
+  if (list && !listKind)
+    throw new Error(`Imported paragraph references missing numbering ${list.numId}/${list.level}`);
+  return {
+    ...importedHeadingLevel ? { headingLevel: importedHeadingLevel } : {},
+    ...alignmentValue ? { alignment: alignmentValue } : {},
+    ...style.spaceBeforePt !== void 0 ? { spaceBeforePt: style.spaceBeforePt } : {},
+    ...style.spaceAfterPt !== void 0 ? { spaceAfterPt: style.spaceAfterPt } : {},
+    ...style.line !== void 0 ? { lineHeight: style.line / 240 } : {},
+    ...style.keepNext !== void 0 ? { keepNext: style.keepNext } : {},
+    ...style.pageBreakBefore !== void 0 ? { pageBreakBefore: style.pageBreakBefore } : {},
+    ...list && listKind ? { list: { kind: listKind, level: list.level, instanceId: list.numId } } : {}
+  };
+}
+function mapImportedRunStyle(style) {
+  if (style.highlight && style.highlight !== "none")
+    throw new UnsupportedArtifactFeatureError("document", "text highlighting", "DOCX import");
+  if (style.verticalAlign && style.verticalAlign !== "baseline")
+    throw new UnsupportedArtifactFeatureError(
+      "document",
+      `text vertical alignment ${style.verticalAlign}`,
+      "DOCX import"
+    );
+  if (style.fontSizeComplexScriptPt !== void 0 && style.fontSizeComplexScriptPt !== style.fontSizePt) {
+    throw new UnsupportedArtifactFeatureError(
+      "document",
+      "script-specific font sizing",
+      "DOCX import"
+    );
+  }
+  if ((style.boldComplexScript ?? false) !== (style.bold ?? false)) {
+    throw new UnsupportedArtifactFeatureError(
+      "document",
+      "script-specific bold formatting",
+      "DOCX import"
+    );
+  }
+  if ((style.italicComplexScript ?? false) !== (style.italic ?? false)) {
+    throw new UnsupportedArtifactFeatureError(
+      "document",
+      "script-specific italic formatting",
+      "DOCX import"
+    );
+  }
+  if (style.language) {
+    throw new UnsupportedArtifactFeatureError("document", "run language metadata", "DOCX import");
+  }
+  return {
+    ...style.fontFamily ? { fontFamily: style.fontFamily } : {},
+    ...style.fontSizePt !== void 0 ? { fontSizePt: style.fontSizePt } : {},
+    ...style.color && style.color !== "auto" ? { color: normalizeHex(style.color) } : {},
+    ...style.bold !== void 0 ? { bold: style.bold } : {},
+    ...style.italic !== void 0 ? { italic: style.italic } : {},
+    ...style.underline !== void 0 ? { underline: style.underline !== "none" } : {},
+    ...style.strike !== void 0 ? { strike: style.strike } : {}
+  };
+}
+function importedPage(section) {
+  return {
+    widthPt: section.page.widthPt,
+    heightPt: section.page.heightPt,
+    marginTopPt: section.page.marginTopPt,
+    marginRightPt: section.page.marginRightPt,
+    marginBottomPt: section.page.marginBottomPt,
+    marginLeftPt: section.page.marginLeftPt,
+    headerPt: section.page.headerPt,
+    footerPt: section.page.footerPt,
+    gutterPt: section.page.gutterPt
+  };
+}
+function validateImportedSections(imported, sections) {
+  if (sections.length === 0) throw new Error("Imported DOCX has no sections");
+  const storyReferences = /* @__PURE__ */ new Set();
+  let expectedStart = 0;
+  for (const section of sections) {
+    for (const reference of [...section.headers, ...section.footers]) {
+      if (storyReferences.has(reference.partName)) {
+        throw new UnsupportedArtifactFeatureError(
+          "document",
+          "linked or inherited header/footer stories",
+          "DOCX import"
+        );
+      }
+      storyReferences.add(reference.partName);
+    }
+    if (section.startBlockIndex !== expectedStart || !Number.isSafeInteger(section.endBlockIndex) || section.endBlockIndex < section.startBlockIndex || section.endBlockIndex > imported.blocks.length) {
+      throw new Error("Imported DOCX sections do not form a contiguous body partition");
+    }
+    expectedStart = section.endBlockIndex;
+    if (section.type !== void 0 && section.type !== "nextPage") {
+      throw new UnsupportedArtifactFeatureError(
+        "document",
+        `section break type ${section.type}`,
+        "DOCX import"
+      );
+    }
+    const orientation = section.page.orientation;
+    if (orientation !== void 0 && orientation !== "portrait" && orientation !== "landscape") {
+      throw new UnsupportedArtifactFeatureError(
+        "document",
+        `page orientation ${orientation}`,
+        "DOCX import"
+      );
+    }
+    if (orientation === "landscape" && section.page.widthPt < section.page.heightPt || orientation === "portrait" && section.page.widthPt > section.page.heightPt) {
+      throw new UnsupportedArtifactFeatureError(
+        "document",
+        "page dimensions inconsistent with page orientation",
+        "DOCX import"
+      );
+    }
+    const hasFirstStory = [...section.headers, ...section.footers].some(
+      (reference) => reference.kind === "first"
+    );
+    if (section.titlePage && !hasFirstStory) {
+      throw new UnsupportedArtifactFeatureError(
+        "document",
+        "first-page header/footer mode without a representable first-page story",
+        "DOCX import"
+      );
+    }
+  }
+  if (expectedStart !== imported.blocks.length) {
+    throw new Error("Imported DOCX sections do not cover the full body");
+  }
+  const hasEvenStory = sections.some(
+    (section) => [...section.headers, ...section.footers].some((reference) => reference.kind === "even")
+  );
+  if (imported.evenAndOddHeaders && !hasEvenStory) {
+    throw new UnsupportedArtifactFeatureError(
+      "document",
+      "even-page header/footer mode without a representable even-page story",
+      "DOCX import"
+    );
+  }
+}
+function importedListKinds(lists) {
+  const result = /* @__PURE__ */ new Map();
+  for (const list of lists) {
+    let instanceSupported = true;
+    for (const override of list.overrides) {
+      if (override.definition || override.start !== void 0 && override.start !== 1) {
+        instanceSupported = false;
+      }
+    }
+    const levels = /* @__PURE__ */ new Map();
+    let definitionSupported = true;
+    for (const level of list.levels) {
+      if (level.start !== 1 || level.restart !== void 0 || level.legal !== void 0 || level.format !== "bullet" && level.format !== "decimal") {
+        definitionSupported = false;
+        continue;
+      }
+      const runtimeLevel = level;
+      const expectedText = level.format === "decimal" ? `%${level.level + 1}.` : void 0;
+      const supportedBullet = level.format === "bullet" && level.text === ["\u2022", "\u25E6", "\u25AA"][level.level % 3];
+      const paragraphEntries = Object.entries(level.paragraph);
+      const hasExpectedIndent = level.paragraph.indentLeftPt !== void 0 && Math.abs(level.paragraph.indentLeftPt - 36 * (level.level + 1)) <= 0.01 && level.paragraph.hangingPt !== void 0 && Math.abs(level.paragraph.hangingPt - 18) <= 0.01;
+      const onlyExpectedIndent = paragraphEntries.every(
+        ([key]) => key === "indentLeftPt" || key === "hangingPt"
+      );
+      if (level.format === "decimal" && level.text !== expectedText || level.format === "bullet" && !supportedBullet || level.suffix !== void 0 && level.suffix !== "tab" || level.paragraphStyleId !== void 0 || runtimeLevel.alignment !== void 0 && runtimeLevel.alignment !== "left" || !hasExpectedIndent || !onlyExpectedIndent || Object.keys(level.run).length > 0) {
+        definitionSupported = false;
+        continue;
+      }
+      levels.set(level.level, level.format === "bullet" ? "bullet" : "number");
+    }
+    result.set(list.numId, instanceSupported && definitionSupported ? levels : /* @__PURE__ */ new Map());
+  }
+  return result;
+}
+function assertRepresentableTableCellParagraph(style, styleId, listKinds) {
+  const projected = mapImportedParagraphStyle(style, styleId, listKinds);
+  const remaining = Object.entries(projected).filter(
+    ([key, value]) => !(key === "alignment" && value === "left" || key === "spaceBeforePt" && value === 0 || key === "spaceAfterPt" && value === 0)
+  );
+  if (remaining.length > 0) {
+    throw new UnsupportedArtifactFeatureError(
+      "document",
+      "paragraph formatting inside table cells",
+      "DOCX import"
+    );
+  }
+}
+function importedUniformCellPadding(source) {
+  const hasExplicitMargins = source.cellMargins !== void 0 || source.rows.some((row) => row.cells.some((cell) => cell.margins !== void 0));
+  if (!hasExplicitMargins) {
+    throw new UnsupportedArtifactFeatureError(
+      "document",
+      "table cell padding inherited from an unrepresented style",
+      "DOCX import"
+    );
+  }
+  const values = [];
+  for (const row of source.rows) {
+    for (const cell of row.cells) {
+      for (const side of ["top", "right", "bottom", "left"]) {
+        const measure = boxMeasure(cell.margins, side) ?? boxMeasure(source.cellMargins, side);
+        if (!measure || measure.unit !== "pt" || !Number.isFinite(measure.value)) {
+          throw new UnsupportedArtifactFeatureError(
+            "document",
+            "asymmetric or non-point table cell margins",
+            "DOCX import"
+          );
+        }
+        values.push(measure.value);
+      }
+    }
+  }
+  const first = values[0];
+  if (first === void 0 || values.some((value) => Math.abs(value - first) > 0.01)) {
+    throw new UnsupportedArtifactFeatureError(
+      "document",
+      "non-uniform table cell padding",
+      "DOCX import"
+    );
+  }
+  return first;
+}
+function boxMeasure(box, side) {
+  if (!box) return void 0;
+  if (side === "left") return box.left ?? box.start;
+  if (side === "right") return box.right ?? box.end;
+  return box[side];
+}
+function importedUniformTableBorder(borders) {
+  if (!borders) {
+    throw new UnsupportedArtifactFeatureError(
+      "document",
+      "table borders inherited from an unrepresented style",
+      "DOCX import"
+    );
+  }
+  const edges = [
+    borders.top,
+    borders.right,
+    borders.bottom,
+    borders.left,
+    borders.insideHorizontal,
+    borders.insideVertical
+  ];
+  if (edges.some((edge) => edge === void 0)) {
+    throw new UnsupportedArtifactFeatureError("document", "partial table borders", "DOCX import");
+  }
+  const colors = edges.map((edge) => {
+    if (edge?.style !== "single" || edge.sizePt === void 0 || Math.abs(edge.sizePt - 0.5) > 0.01 || (edge.spacePt ?? 0) !== 0 || edge.shadow === true || edge.frame === true || !edge.color || edge.color.toLowerCase() === "auto") {
+      throw new UnsupportedArtifactFeatureError(
+        "document",
+        "non-uniform or decorated table borders",
+        "DOCX import"
+      );
+    }
+    return normalizeHex(edge.color);
+  });
+  const first = colors[0];
+  if (colors.some((color) => color !== first)) {
+    throw new UnsupportedArtifactFeatureError(
+      "document",
+      "mixed table border colors",
+      "DOCX import"
+    );
+  }
+  return first;
+}
+function isOnlyPageBreak(paragraph, styles) {
+  const inherited = resolveImportedStyle(paragraph.styleId, styles, "paragraph");
+  return paragraph.inlines.length === 1 && paragraph.inlines[0]?.kind === "pageBreak" && paragraph.commentAnchors.length === 0 && Object.keys({ ...inherited.paragraph, ...paragraph.style }).length === 0 && Object.keys(inherited.run).length === 0;
+}
+function importedCommentText(comment, styles) {
+  const paragraph = comment.blocks[0];
+  if (comment.blocks.length !== 1 || paragraph?.kind !== "paragraph" || paragraph.styleId !== void 0 || Object.keys(paragraph.style).length > 0 || paragraph.inlines.some(
+    (inline) => inline.kind !== "run" || inline.styleId !== void 0 || Object.keys(inline.style).length > 0
+  ) || paragraph.commentAnchors.length > 0) {
+    throw new UnsupportedArtifactFeatureError(
+      "document",
+      "multi-paragraph or formatted content inside comments",
+      "DOCX import"
+    );
+  }
+  const defaults = resolveImportedStyle(void 0, styles, "paragraph");
+  if (Object.keys(defaults.paragraph).length > 0 || Object.keys(defaults.run).length > 0) {
+    throw new UnsupportedArtifactFeatureError(
+      "document",
+      "formatted default style inside comments",
+      "DOCX import"
+    );
+  }
+  return paragraph.inlines.map((inline) => inline.kind === "run" ? inline.text : "").join("");
+}
+function inlineIndexToTextOffset(paragraph, index) {
+  if (!Number.isInteger(index) || index < 0 || index > paragraph.inlines.length)
+    throw new Error("Imported tracked-change inline index is invalid");
+  return paragraph.inlines.slice(0, index).reduce((total, inline) => total + (inline.kind === "run" ? inline.text.length : 0), 0);
+}
+function normalizedImportedDate(value) {
+  if (!value) {
+    throw new UnsupportedArtifactFeatureError(
+      "document",
+      "comment or tracked-change timestamp omitted",
+      "DOCX import"
+    );
+  }
+  const date = new Date(value);
+  if (!Number.isFinite(date.getTime()))
+    throw new Error(`Imported DOCX contains an invalid timestamp: ${value}`);
+  return date.toISOString();
+}
+function buildDocxContext(document, docx) {
+  const commentsByBlock = /* @__PURE__ */ new Map();
+  const commentDefinitions = [];
+  let commentId = 0;
+  for (const thread of document.comments.items) {
+    const rootId = commentId++;
+    appendMap(commentsByBlock, thread.blockId, { thread, numericId: rootId });
+    thread.replies.forEach((reply, index) => {
+      const id = index === 0 ? rootId : commentId++;
+      commentDefinitions.push({
+        id,
+        ...index > 0 ? { parentId: rootId } : {},
+        author: reply.author,
+        initials: initials(reply.author),
+        date: new Date(reply.createdAt),
+        ...index === 0 ? { resolved: thread.resolved } : {},
+        children: [
+          new docx.Paragraph({
+            children: [new docx.TextRun(docxTextRunOptions(reply.text, {}, docx))]
+          })
+        ]
+      });
+    });
+  }
+  const changesByBlock = /* @__PURE__ */ new Map();
+  document.changes.items.forEach(
+    (change, numericId) => appendMap(changesByBlock, change.blockId, { change, numericId })
+  );
+  return {
+    commentsByBlock,
+    changesByBlock,
+    commentDefinitions,
+    listInstances: buildListInstances(document)
+  };
+}
+function buildDocxStories(stories, page, docx, context) {
+  const make = (story, emitEmpty) => {
+    if (story.items.length === 0 && !emitEmpty) return void 0;
+    const children2 = story.items.length > 0 ? story.items.map((block) => toDocxBlock(block, page, docx, context)) : [new docx.Paragraph({ children: [] })];
+    return story.kind === "header" ? new docx.Header({ children: children2 }) : new docx.Footer({ children: children2 });
+  };
+  const result = {};
+  const defaultStory = make(stories.default, true);
+  const firstStory = make(stories.first, true);
+  const evenStory = make(stories.even, true);
+  if (defaultStory) result.default = defaultStory;
+  if (firstStory) result.first = firstStory;
+  if (evenStory) result.even = evenStory;
+  return result;
+}
+function toDocxBlock(block, page, docx, context) {
+  if (block instanceof DocumentPageBreak) {
+    return new docx.Paragraph({ children: [new docx.PageBreak()] });
+  }
+  if (block instanceof DocumentTable) return toDocxTable(block, page, docx);
+  const heading = headingLevel(block.style.headingLevel, docx);
+  const paragraphAlignment = alignment(block.style.alignment, docx);
+  const spacing = {
+    ...block.style.spaceBeforePt !== void 0 ? { before: ptToTwip(block.style.spaceBeforePt) } : {},
+    ...block.style.spaceAfterPt !== void 0 ? { after: ptToTwip(block.style.spaceAfterPt) } : {},
+    ...block.style.lineHeight !== void 0 ? { line: Math.round(block.style.lineHeight * 240) } : {}
+  };
+  const list = block.style.list;
+  return new docx.Paragraph({
+    ...heading ? { heading } : {},
+    ...paragraphAlignment ? { alignment: paragraphAlignment } : {},
+    ...Object.keys(spacing).length > 0 ? { spacing } : {},
+    ...block.style.keepNext !== void 0 ? { keepNext: block.style.keepNext } : {},
+    ...block.style.pageBreakBefore !== void 0 ? { pageBreakBefore: block.style.pageBreakBefore } : {},
+    ...list ? {
+      numbering: {
+        reference: list.kind === "bullet" ? "opengeni-bullet" : "opengeni-number",
+        level: list.level ?? 0,
+        ...context.listInstances.has(block.id) ? { instance: context.listInstances.get(block.id) } : {}
+      }
+    } : {},
+    children: toDocxParagraphChildren(block, docx, context)
+  });
+}
+function toDocxTable(block, page, docx) {
+  const columnCount = block.rows[0]?.length ?? 0;
+  const usableWidth = page.widthPt - page.marginLeftPt - page.marginRightPt;
+  const totalWidth = block.style.widthPt ?? block.style.columnWidthsPt?.reduce((total, width) => total + width, 0) ?? usableWidth;
+  const columnWidths = block.style.columnWidthsPt ?? Array.from({ length: columnCount }, () => totalWidth / columnCount);
+  const columnWidthsTwip = columnWidths.map(ptToTwip);
+  const tableWidthTwip = columnWidthsTwip.reduce((sum, width) => sum + width, 0);
+  const padding = ptToTwip(block.style.cellPaddingPt ?? 6);
+  const borderColor = normalizeHex(block.style.borderColor ?? "#D1D5DB").slice(1);
+  const border = { style: docx.BorderStyle.SINGLE, size: 4, color: borderColor };
+  return new docx.Table({
+    width: { size: tableWidthTwip, type: docx.WidthType.DXA },
+    columnWidths: columnWidthsTwip,
+    indent: { size: padding, type: docx.WidthType.DXA },
+    layout: docx.TableLayoutType.FIXED,
+    margins: { top: padding, bottom: padding, left: padding, right: padding },
+    borders: {
+      top: border,
+      bottom: border,
+      left: border,
+      right: border,
+      insideHorizontal: border,
+      insideVertical: border
+    },
+    rows: block.rows.map(
+      (row, rowIndex) => new docx.TableRow({
+        tableHeader: rowIndex < (block.style.headerRows ?? 0),
+        cantSplit: !(block.style.allowRowSplit ?? false),
+        children: row.map(
+          (cell, columnIndex) => new docx.TableCell({
+            width: {
+              size: columnWidthsTwip[columnIndex] ?? ptToTwip(72),
+              type: docx.WidthType.DXA
+            },
+            verticalAlign: docx.VerticalAlign.CENTER,
+            margins: { top: padding, bottom: padding, left: padding, right: padding },
+            ...rowIndex < (block.style.headerRows ?? 0) && block.style.headerFill ? { shading: { fill: normalizeHex(block.style.headerFill).slice(1) } } : {},
+            children: [
+              new docx.Paragraph({ children: cell.map((run) => toDocxTextRun(run, docx)) })
+            ]
+          })
+        )
+      })
+    )
+  });
+}
+function toDocxParagraphChildren(block, docx, context) {
+  const comments = context.commentsByBlock.get(block.id) ?? [];
+  const changes = context.changesByBlock.get(block.id) ?? [];
+  const paragraphText = block.text;
+  validateNonCrossingComments(comments.map(({ thread }) => thread));
+  validateNonOverlappingChanges(changes.map(({ change }) => change));
+  validateReviewMarkupForDocx(
+    block,
+    comments.map(({ thread }) => thread),
+    changes.map(({ change }) => change)
+  );
+  const boundaries = /* @__PURE__ */ new Set([0, paragraphText.length]);
+  const runSpans = [];
+  const pointComments = /* @__PURE__ */ new Map();
+  const openingComments = /* @__PURE__ */ new Map();
+  const closingComments = /* @__PURE__ */ new Map();
+  let offset = 0;
+  for (const run of block.runs) {
+    const start = offset;
+    offset += run.text.length;
+    runSpans.push({ start, end: offset, run });
+    boundaries.add(start);
+    boundaries.add(offset);
+  }
+  for (const { thread } of comments) {
+    boundaries.add(thread.start);
+    boundaries.add(thread.end);
+  }
+  for (const comment of comments) {
+    if (comment.thread.start === comment.thread.end) {
+      appendMap(pointComments, comment.thread.start, comment);
+    } else {
+      appendMap(openingComments, comment.thread.start, comment);
+      appendMap(closingComments, comment.thread.end, comment);
+    }
+  }
+  for (const values of openingComments.values()) {
+    values.sort((left, right) => right.thread.end - left.thread.end);
+  }
+  for (const values of closingComments.values()) {
+    values.sort((left, right) => right.thread.start - left.thread.start);
+  }
+  for (const { change } of changes) {
+    boundaries.add(change.start);
+    boundaries.add(change.end);
+  }
+  const points = [...boundaries].sort((a, b) => a - b);
+  const sortedChanges = [...changes].sort(
+    (left, right) => left.change.start - right.change.start || left.change.end - right.change.end
+  );
+  const children2 = [];
+  if (paragraphText.length === 0) {
+    for (const { numericId } of pointComments.get(0) ?? []) {
+      children2.push(
+        new docx.CommentRangeStart(numericId),
+        new docx.CommentRangeEnd(numericId),
+        commentReferenceRun(numericId, docx)
+      );
+    }
+    children2.push(...block.runs.map((run) => toDocxTextRun(run, docx)));
+    return children2;
+  }
+  let runIndex = 0;
+  let changeIndex = 0;
+  for (let index = 0; index < points.length; index++) {
+    const point = points[index];
+    for (const { numericId } of pointComments.get(point) ?? []) {
+      children2.push(
+        new docx.CommentRangeStart(numericId),
+        new docx.CommentRangeEnd(numericId),
+        commentReferenceRun(numericId, docx)
+      );
+    }
+    for (const { numericId } of openingComments.get(point) ?? []) {
+      children2.push(new docx.CommentRangeStart(numericId));
+    }
+    const next = points[index + 1];
+    if (next !== void 0 && next > point) {
+      while (runSpans[runIndex] && runSpans[runIndex].end <= point) runIndex += 1;
+      const span = runSpans[runIndex];
+      if (!span) throw new Error(`Document paragraph ${block.id} has a discontinuous run map`);
+      if (span.start > point || span.end < next)
+        throw new Error(`Document paragraph ${block.id} has a discontinuous run map`);
+      const text = span.run.text.slice(point - span.start, next - span.start);
+      while (sortedChanges[changeIndex]?.change.end !== void 0 && sortedChanges[changeIndex].change.end <= point) {
+        changeIndex += 1;
+      }
+      const candidate = sortedChanges[changeIndex];
+      const active = candidate && candidate.change.start <= point && candidate.change.end >= next ? candidate : void 0;
+      if (!active || point === active.change.start) {
+        children2.push(
+          active ? toDocxChangedTextRun(
+            paragraphText.slice(active.change.start, active.change.end),
+            span.run.style,
+            active,
+            docx
+          ) : toDocxChangedTextRun(text, span.run.style, void 0, docx)
+        );
+      }
+    }
+    if (next !== void 0) {
+      for (const { numericId } of closingComments.get(next) ?? []) {
+        children2.push(new docx.CommentRangeEnd(numericId));
+        children2.push(commentReferenceRun(numericId, docx));
+      }
+    }
+  }
+  return children2;
+}
+function commentReferenceRun(numericId, docx) {
+  return new docx.TextRun({ children: [new docx.CommentReference(numericId)] });
+}
+function toDocxChangedTextRun(text, style, active, docx) {
+  const options = docxTextRunOptions(text, style, docx);
+  if (!active) return materializedTextRun(text, options, docx);
+  const changeOptions = {
+    ...options,
+    id: active.numericId,
+    author: active.change.author,
+    date: active.change.createdAt
+  };
+  return active.change.kind === "insert" ? new docx.InsertedTextRun(changeOptions) : new docx.DeletedTextRun(changeOptions);
+}
+function toDocxTextRun(run, docx) {
+  return materializedTextRun(run.text, docxTextRunOptions(run.text, run.style, docx), docx);
+}
+function materializedTextRun(text, options, docx) {
+  if (text.length > 0) return new docx.TextRun(options);
+  const { text: _text, children: _children, ...properties } = options;
+  return new docx.Run({
+    ...properties,
+    children: [new docx.EmptyElement("w:t")]
+  });
+}
+function docxTextRunOptions(text, style, docx) {
+  return {
+    ...text.includes("	") || text.includes("\n") ? { children: docxTextChildren(text, docx) } : { text },
+    ...style.fontFamily ? { font: style.fontFamily } : {},
+    ...style.fontSizePt !== void 0 ? { size: Math.round(style.fontSizePt * 2) } : {},
+    ...style.color ? { color: normalizeHex(style.color).slice(1) } : {},
+    ...style.bold !== void 0 ? { bold: style.bold } : {},
+    ...style.italic !== void 0 ? { italics: style.italic } : {},
+    ...style.underline !== void 0 ? {
+      underline: {
+        type: style.underline ? docx.UnderlineType.SINGLE : docx.UnderlineType.NONE
+      }
+    } : {},
+    ...style.strike !== void 0 ? { strike: style.strike } : {}
+  };
+}
+function docxTextChildren(text, docx) {
+  const children2 = [];
+  let start = 0;
+  for (let index = 0; index < text.length; index += 1) {
+    const character = text[index];
+    if (character !== "	" && character !== "\n") continue;
+    if (index > start) children2.push(text.slice(start, index));
+    children2.push(character === "	" ? new docx.Tab() : new docx.CarriageReturn());
+    start = index + 1;
+  }
+  if (start < text.length) children2.push(text.slice(start));
+  return children2;
+}
+function numberingConfig(docx) {
+  const makeLevels = (kind) => Array.from({ length: 9 }, (_, level) => ({
+    level,
+    format: kind === "bullet" ? docx.LevelFormat.BULLET : docx.LevelFormat.DECIMAL,
+    text: kind === "bullet" ? ["\u2022", "\u25E6", "\u25AA"][level % 3] : `%${level + 1}.`,
+    alignment: docx.AlignmentType.LEFT,
+    style: { paragraph: { indent: { left: 720 * (level + 1), hanging: 360 } } }
+  }));
+  return [
+    { reference: "opengeni-bullet", levels: makeLevels("bullet") },
+    { reference: "opengeni-number", levels: makeLevels("number") }
+  ];
+}
+function buildListInstances(document) {
+  const instances = /* @__PURE__ */ new Map();
+  const explicitInstances = /* @__PURE__ */ new Map();
+  let instance = 0;
+  const visit = (blocks) => {
+    let activeKind;
+    for (const block of blocks) {
+      if (!(block instanceof DocumentParagraph) || !block.style.list) {
+        activeKind = void 0;
+        continue;
+      }
+      const explicitId = block.style.list.instanceId;
+      if (explicitId) {
+        const key = `${block.style.list.kind}:${explicitId}`;
+        let explicitInstance = explicitInstances.get(key);
+        if (explicitInstance === void 0) {
+          explicitInstance = ++instance;
+          explicitInstances.set(key, explicitInstance);
+        }
+        instances.set(block.id, explicitInstance);
+        activeKind = void 0;
+        continue;
+      }
+      if (activeKind !== block.style.list.kind) instance += 1;
+      activeKind = block.style.list.kind;
+      instances.set(block.id, instance);
+    }
+  };
+  visit(document.blocks.items);
+  for (const section of document.sections.items)
+    for (const story of section.allStories()) visit(story.items);
+  return instances;
+}
+function headingLevel(level, docx) {
+  if (!level) return void 0;
+  return [
+    docx.HeadingLevel.HEADING_1,
+    docx.HeadingLevel.HEADING_2,
+    docx.HeadingLevel.HEADING_3,
+    docx.HeadingLevel.HEADING_4,
+    docx.HeadingLevel.HEADING_5,
+    docx.HeadingLevel.HEADING_6
+  ][level - 1];
+}
+function alignment(value, docx) {
+  if (!value) return void 0;
+  return {
+    left: docx.AlignmentType.LEFT,
+    center: docx.AlignmentType.CENTER,
+    right: docx.AlignmentType.RIGHT,
+    justify: docx.AlignmentType.JUSTIFIED
+  }[value];
+}
+function validateNonOverlappingChanges(changes) {
+  const sorted = [...changes].sort((a, b) => a.start - b.start || a.end - b.end);
+  for (let index = 1; index < sorted.length; index++) {
+    if (sorted[index].start < sorted[index - 1].end) {
+      throw new UnsupportedArtifactFeatureError(
+        "document",
+        "overlapping tracked changes",
+        "DOCX export"
+      );
+    }
+  }
+}
+function validateNonCrossingComments(comments) {
+  const sorted = [...comments].sort(
+    (left, right) => left.start - right.start || right.end - left.end
+  );
+  const activeEnds = [];
+  for (const comment of sorted) {
+    while (activeEnds.length > 0 && comment.start >= activeEnds[activeEnds.length - 1]) {
+      activeEnds.pop();
+    }
+    const enclosingEnd = activeEnds[activeEnds.length - 1];
+    if (enclosingEnd !== void 0 && comment.end > enclosingEnd) {
+      throw new UnsupportedArtifactFeatureError(
+        "document",
+        "crossing comment ranges",
+        "DOCX export"
+      );
+    }
+    if (comment.end > comment.start) activeEnds.push(comment.end);
+  }
+}
+function validateReviewMarkupForDocx(paragraph, comments, changes) {
+  const runSlices = paragraphRunSlices(paragraph);
+  const sortedChanges = [...changes].sort(
+    (left, right) => left.start - right.start || left.end - right.end
+  );
+  let runIndex = 0;
+  for (const change of sortedChanges) {
+    while (runSlices[runIndex] && runSlices[runIndex].end <= change.start) runIndex += 1;
+    let scanIndex = runIndex;
+    let firstStyle;
+    while (runSlices[scanIndex] && runSlices[scanIndex].start < change.end) {
+      const style = runSlices[scanIndex].run.style;
+      firstStyle ??= style;
+      if (!sameTextStyle(style, firstStyle)) {
+        throw new UnsupportedArtifactFeatureError(
+          "document",
+          "one tracked change spanning multiple text styles",
+          "DOCX export"
+        );
+      }
+      scanIndex += 1;
+    }
+  }
+  const sortedComments = [...comments].sort(
+    (left, right) => left.start - right.start || left.end - right.end
+  );
+  let changeIndex = 0;
+  for (const comment of sortedComments) {
+    while (sortedChanges[changeIndex] && sortedChanges[changeIndex].end <= comment.start) {
+      changeIndex += 1;
+    }
+    const change = sortedChanges[changeIndex];
+    if (!change) continue;
+    const pointInside = comment.start === comment.end && comment.start > change.start && comment.start < change.end;
+    const rangesOverlap = comment.start < change.end && comment.end > change.start;
+    const aligned = comment.start === change.start && comment.end === change.end;
+    if (pointInside || rangesOverlap && !aligned) {
+      throw new UnsupportedArtifactFeatureError(
+        "document",
+        "interleaved comments and tracked changes",
+        "DOCX export"
+      );
+    }
+  }
+}
+function paragraphRunSlices(paragraph) {
+  const result = [];
+  let offset = 0;
+  for (const run of paragraph.runs) {
+    const start = offset;
+    offset += run.text.length;
+    result.push({ start, end: offset, run });
+  }
+  return result;
+}
+function sameTextStyle(left, right) {
+  return left.fontFamily === right.fontFamily && left.fontSizePt === right.fontSizePt && left.color === right.color && left.bold === right.bold && left.italic === right.italic && left.underline === right.underline && left.strike === right.strike;
+}
+var MAX_DOCX_SOURCE_BYTES = 32 * 1024 * 1024;
+function validateImportOptions(options) {
+  assertPlainDataRecord(options, /* @__PURE__ */ new Set(["unsupportedContent", "limits"]), "DOCX import options");
+  if (options.unsupportedContent !== void 0 && options.unsupportedContent !== "preserve" && options.unsupportedContent !== "error")
+    throw new TypeError("DOCX unsupportedContent import policy is invalid");
+  if (options.limits !== void 0) {
+    assertPlainDataRecord(options.limits, void 0, "DOCX import limits");
+  }
+}
+function validateExportOptions(options) {
+  assertPlainDataRecord(
+    options,
+    /* @__PURE__ */ new Set(["fileName", "unsupportedContent"]),
+    "DOCX export options"
+  );
+  if (options.unsupportedContent !== void 0 && options.unsupportedContent !== "error" && options.unsupportedContent !== "discard")
+    throw new TypeError("DOCX unsupportedContent export policy is invalid");
+  if (options.fileName !== void 0 && (typeof options.fileName !== "string" || options.fileName.length === 0 || options.fileName.length > 255))
+    throw new TypeError("DOCX export fileName must contain 1 through 255 characters");
+}
+function validateAttachOptions(options) {
+  assertPlainDataRecord(options, /* @__PURE__ */ new Set(["limits"]), "DOCX envelope attach options");
+  if (options.limits !== void 0) {
+    assertPlainDataRecord(options.limits, void 0, "DOCX import limits");
+  }
+}
+function assertPlainDataRecord(value, allowedKeys, label) {
+  if (value === null || typeof value !== "object" || Array.isArray(value) || Object.getPrototypeOf(value) !== Object.prototype)
+    throw new TypeError(`${label} must be a plain data object`);
+  if (Object.getOwnPropertySymbols(value).length > 0) {
+    throw new TypeError(`${label} must not contain symbol properties`);
+  }
+  for (const [key, descriptor] of Object.entries(Object.getOwnPropertyDescriptors(value))) {
+    if (!("value" in descriptor) || !descriptor.enumerable) {
+      throw new TypeError(`${label} must contain only enumerable data properties`);
+    }
+    if (allowedKeys && !allowedKeys.has(key))
+      throw new TypeError(`${label} contains unknown property ${key}`);
+  }
+}
+async function ownedDocxBytes(input) {
+  if (input instanceof ArrayBuffer) {
+    if (input.byteLength > MAX_DOCX_SOURCE_BYTES) {
+      throw new DocxImportError("limit_exceeded", "Compressed DOCX exceeds maxCompressedBytes");
+    }
+    return new Uint8Array(input.slice(0));
+  }
+  if (typeof Blob !== "undefined" && input instanceof Blob) {
+    const size = Object.getOwnPropertyDescriptor(Blob.prototype, "size")?.get?.call(input);
+    if (typeof size !== "number" || size > MAX_DOCX_SOURCE_BYTES) {
+      throw new DocxImportError("limit_exceeded", "Compressed DOCX exceeds maxCompressedBytes");
+    }
+    return new Uint8Array(await Blob.prototype.arrayBuffer.call(input));
+  }
+  throw new DocxImportError("invalid_input", "DOCX input must be a Blob or ArrayBuffer");
+}
+function ownedArrayBuffer(bytes) {
+  const copy = new Uint8Array(bytes.byteLength);
+  copy.set(bytes);
+  return copy.buffer;
+}
+function deterministicCoreProperties(revision) {
+  return `<?xml version="1.0" encoding="UTF-8" standalone="yes"?><cp:coreProperties xmlns:cp="http://schemas.openxmlformats.org/package/2006/metadata/core-properties" xmlns:dc="http://purl.org/dc/elements/1.1/"><dc:creator>OpenGeni</dc:creator><cp:lastModifiedBy>OpenGeni</cp:lastModifiedBy><cp:revision>${revision}</cp:revision></cp:coreProperties>`;
+}
+function hasOpaqueContent(content) {
+  return content.parts.length > 0 || content.relationships.length > 0 || content.contentTypes.length > 0;
+}
+function opaqueContentIssue(content, severity) {
+  return {
+    code: severity === "warning" ? "content-preserved-in-source" : "content-will-be-discarded",
+    severity,
+    feature: "opaque-ooxml",
+    message: severity === "warning" ? "The DOCX contains bounded inert OOXML outside the editable model; unchanged export preserves the package byte-for-byte" : "The DOCX contains bounded inert OOXML outside the editable model and cannot be imported under the requested strict fidelity policy",
+    ...cloneOpaqueContent(content)
+  };
+}
+function cloneOpaqueContent(content) {
+  return {
+    parts: [...content.parts],
+    relationships: content.relationships.map((relationship) => ({ ...relationship })),
+    contentTypes: content.contentTypes.map((contentType) => ({ ...contentType }))
+  };
+}
+function sameOpaqueContent(left, right) {
+  return JSON.stringify(left) === JSON.stringify(right);
+}
+function normalizeLossPreservationEnvelope(value) {
+  assertPlainDataRecord(
+    value,
+    /* @__PURE__ */ new Set([
+      "version",
+      "mediaType",
+      "sourceBytes",
+      "sourceDigest",
+      "opaqueContent",
+      "modelDigest"
+    ]),
+    "DOCX loss-preservation envelope"
+  );
+  if (value.version !== 1 || value.mediaType !== DOCX_MEDIA_TYPE) {
+    throw new TypeError("DOCX loss-preservation envelope version or media type is invalid");
+  }
+  if (!(value.sourceBytes instanceof Uint8Array) || Object.getPrototypeOf(value.sourceBytes) !== Uint8Array.prototype || value.sourceBytes.byteLength > MAX_DOCX_SOURCE_BYTES)
+    throw new TypeError("DOCX loss-preservation sourceBytes must be a bounded Uint8Array");
+  if (typeof value.sourceDigest !== "string" || !/^[0-9a-f]{64}$/.test(value.sourceDigest)) {
+    throw new TypeError("DOCX loss-preservation sourceDigest must be canonical SHA-256");
+  }
+  if (typeof value.modelDigest !== "string" || !/^[0-9a-f]{64}$/.test(value.modelDigest)) {
+    throw new TypeError("DOCX loss-preservation modelDigest must be canonical SHA-256");
+  }
+  const opaqueContent = normalizeOpaqueContent(value.opaqueContent);
+  if (!hasOpaqueContent(opaqueContent)) {
+    throw new TypeError("DOCX loss-preservation envelope contains no opaque content");
+  }
+  return {
+    version: 1,
+    mediaType: DOCX_MEDIA_TYPE,
+    sourceBytes: value.sourceBytes.slice(),
+    sourceDigest: value.sourceDigest,
+    opaqueContent,
+    modelDigest: value.modelDigest
+  };
+}
+function normalizeOpaqueContent(value) {
+  assertPlainDataRecord(
+    value,
+    /* @__PURE__ */ new Set(["parts", "relationships", "contentTypes"]),
+    "DOCX opaque-content metadata"
+  );
+  const parts = denseDataArray(value.parts, 1024, "DOCX opaque part list").map((part) => {
+    if (typeof part !== "string" || part.length === 0 || part.length > 1025) {
+      throw new TypeError("DOCX opaque part name is invalid");
+    }
+    return part;
+  });
+  const relationships = denseDataArray(
+    value.relationships,
+    1e5,
+    "DOCX opaque relationship list"
+  ).map((relationship) => {
+    assertPlainDataRecord(
+      relationship,
+      /* @__PURE__ */ new Set(["sourcePart", "type", "targetPart"]),
+      "DOCX opaque relationship"
+    );
+    const { sourcePart, type, targetPart } = relationship;
+    if (typeof sourcePart !== "string" || sourcePart.length > 1025 || typeof type !== "string" || type.length === 0 || type.length > 2048 || typeof targetPart !== "string" || targetPart.length === 0 || targetPart.length > 1025)
+      throw new TypeError("DOCX opaque relationship metadata is invalid");
+    return { sourcePart, type, targetPart };
+  });
+  const contentTypes = denseDataArray(
+    value.contentTypes,
+    1024,
+    "DOCX opaque content-type list"
+  ).map((contentType) => {
+    assertPlainDataRecord(
+      contentType,
+      /* @__PURE__ */ new Set(["partName", "contentType"]),
+      "DOCX opaque content type"
+    );
+    if (typeof contentType.partName !== "string" || contentType.partName.length === 0 || contentType.partName.length > 1025 || typeof contentType.contentType !== "string" || contentType.contentType.length === 0 || contentType.contentType.length > 2048)
+      throw new TypeError("DOCX opaque content-type metadata is invalid");
+    return { partName: contentType.partName, contentType: contentType.contentType };
+  });
+  return { parts, relationships, contentTypes };
+}
+function denseDataArray(value, maximum, label) {
+  if (!Array.isArray(value) || Object.getPrototypeOf(value) !== Array.prototype || value.length > maximum) {
+    throw new TypeError(`${label} must be a bounded ordinary array`);
+  }
+  const descriptors = Object.getOwnPropertyDescriptors(value);
+  for (let index = 0; index < value.length; index += 1) {
+    const descriptor = descriptors[String(index)];
+    if (!descriptor || !("value" in descriptor) || !descriptor.enumerable) {
+      throw new TypeError(`${label} must contain only dense data elements`);
+    }
+  }
+  for (const key of Object.keys(descriptors)) {
+    if (key !== "length" && !/^(?:0|[1-9][0-9]*)$/.test(key)) {
+      throw new TypeError(`${label} contains an unknown property`);
+    }
+  }
+  return value.slice();
+}
+async function documentModelDigest(document) {
+  return sha256Hex(new TextEncoder().encode(JSON.stringify(document.toJSON())));
+}
+async function sha256Hex(bytes) {
+  const ownedBytes = new Uint8Array(bytes.byteLength);
+  ownedBytes.set(bytes);
+  const digest = new Uint8Array(await globalThis.crypto.subtle.digest("SHA-256", ownedBytes));
+  return [...digest].map((byte) => byte.toString(16).padStart(2, "0")).join("");
+}
+async function semanticNamespace(value) {
+  const { opaqueContent: _opaqueContent, ...semanticValue } = value;
+  const canonicalBytes = new TextEncoder().encode(JSON.stringify(semanticValue));
+  const digest = new Uint8Array(await globalThis.crypto.subtle.digest("SHA-256", canonicalBytes));
+  return [...digest.subarray(0, 8)].map((byte) => byte.toString(16).padStart(2, "0")).join("");
+}
+function appendMap(map, key, value) {
+  const values = map.get(key);
+  if (values) values.push(value);
+  else map.set(key, [value]);
+}
+function initials(author) {
+  const value = author.trim().split(/\s+/u).slice(0, 2).map((part) => Array.from(part)[0]?.toUpperCase() ?? "").join("");
+  return Array.from(value).slice(0, 8).join("") || "U";
+}
+function assertRepresentableCommentInitials(author, value) {
+  if (value !== void 0 && value !== initials(author)) {
+    throw new UnsupportedArtifactFeatureError("document", "custom comment initials", "DOCX import");
+  }
+}
+function ptToTwip(value) {
+  return Math.round(value * 20);
+}
+function normalizeHex(value) {
+  if (!/^#?[0-9A-Fa-f]{6}$/.test(value)) throw new Error(`Invalid or unsafe color: ${value}`);
+  return `#${value.replace(/^#/, "").toUpperCase()}`;
+}
+export {
+  DOCX_MEDIA_TYPE,
+  DocumentFidelityError,
+  attachLossPreservationEnvelope,
+  exportDocx,
+  fidelityReport,
+  importDocx2 as importDocx,
+  lossPreservationEnvelope
+};
+//# sourceMappingURL=document-docx-codec.js.map