@beyondwork/docx-react-component 1.0.27 → 1.0.29

package/dist/chunk-WGBAKP3Q.js

@@ -0,0 +1,3220 @@
+import {
+  CONTENT_TYPES_PATH,
+  PACKAGE_RELATIONSHIPS_PATH,
+  comparePartPaths,
+  getExtension,
+  getRelationshipsPartPath,
+  normalizePartPath,
+  resolveRelationshipTarget
+} from "./chunk-FUDY333O.js";
+import {
+  getOpaqueFragment
+} from "./chunk-SWKWQZXM.js";
+
+// src/io/opc/package-writer.ts
+function writeOpcPackage(input) {
+  const entries = collectZipEntries(input.manifest, input.parts);
+  return buildZipArchive(entries);
+}
+function collectZipEntries(manifest, parts) {
+  const entries = [];
+  const contentParts = [...parts.values()].filter((part) => part.surfaceKind === "content").sort((left, right) => comparePartPaths(left.path, right.path));
+  entries.push(createZipPayload(CONTENT_TYPES_PATH, "deflate", encodeXml(buildContentTypesXml(manifest, contentParts))));
+  entries.push(
+    createZipPayload(
+      PACKAGE_RELATIONSHIPS_PATH,
+      "deflate",
+      encodeXml(buildRelationshipsXml(manifest.packageRelationships))
+    )
+  );
+  for (const part of contentParts) {
+    entries.push(createZipPayload(part.path, part.compression, part.bytes));
+    if (part.relationships.length > 0) {
+      entries.push(
+        createZipPayload(
+          getRelationshipsPartPath(part.path),
+          "deflate",
+          encodeXml(buildRelationshipsXml(part.relationships))
+        )
+      );
+    }
+  }
+  return entries.sort((left, right) => comparePartPaths(left.path, right.path));
+}
+function buildContentTypesXml(manifest, parts) {
+  const defaults = {
+    ...manifest.contentTypes.defaults,
+    rels: manifest.contentTypes.defaults.rels ?? "application/vnd.openxmlformats-package.relationships+xml",
+    xml: manifest.contentTypes.defaults.xml ?? "application/xml"
+  };
+  const overrides = { ...manifest.contentTypes.overrides };
+  for (const part of parts) {
+    if (!part.contentType) {
+      throw new Error(`Cannot write OPC package: missing content type for ${part.path}.`);
+    }
+    const extension = getExtension(part.path);
+    if (!extension) {
+      overrides[part.path] = part.contentType;
+      continue;
+    }
+    const defaultContentType = defaults[extension];
+    if (!defaultContentType) {
+      defaults[extension] = part.contentType;
+      delete overrides[part.path];
+      continue;
+    }
+    if (defaultContentType === part.contentType) {
+      delete overrides[part.path];
+      continue;
+    }
+    overrides[part.path] = part.contentType;
+  }
+  const defaultEntries = Object.entries(defaults).sort(([left], [right]) => left.localeCompare(right));
+  const overrideEntries = Object.entries(overrides).sort(([left], [right]) => comparePartPaths(left, right));
+  const defaultXml = defaultEntries.map(([extension, contentType]) => `  <Default Extension="${escapeXml(extension)}" ContentType="${escapeXml(contentType)}"/>`).join("\n");
+  const overrideXml = overrideEntries.map(([partName, contentType]) => `  <Override PartName="${escapeXml(partName)}" ContentType="${escapeXml(contentType)}"/>`).join("\n");
+  const body = [defaultXml, overrideXml].filter((value) => value.length > 0).join("\n");
+  return [
+    `<?xml version="1.0" encoding="UTF-8" standalone="yes"?>`,
+    `<Types xmlns="http://schemas.openxmlformats.org/package/2006/content-types">`,
+    body,
+    `</Types>`
+  ].join("\n");
+}
+function buildRelationshipsXml(relationships) {
+  const relationshipXml = [...relationships].sort((left, right) => left.id.localeCompare(right.id)).map((relationship) => {
+    const targetMode = relationship.targetMode === "external" ? ` TargetMode="External"` : "";
+    return `  <Relationship Id="${escapeXml(relationship.id)}" Type="${escapeXml(relationship.type)}" Target="${escapeXml(relationship.target)}"${targetMode}/>`;
+  }).join("\n");
+  return [
+    `<?xml version="1.0" encoding="UTF-8" standalone="yes"?>`,
+    `<Relationships xmlns="http://schemas.openxmlformats.org/package/2006/relationships">`,
+    relationshipXml,
+    `</Relationships>`
+  ].join("\n");
+}
+function createZipPayload(path, compression, bytes) {
+  const normalizedPath = normalizePartPath(path).slice(1);
+  const uncompressedBytes = new Uint8Array(bytes);
+  const compressedBytes = uncompressedBytes;
+  const effectiveCompression = "store";
+  return {
+    path: normalizedPath,
+    compression: effectiveCompression,
+    uncompressedBytes,
+    compressedBytes,
+    crc32: calculateCrc32(uncompressedBytes)
+  };
+}
+function buildZipArchive(entries) {
+  const localChunks = [];
+  const centralChunks = [];
+  let localOffset = 0;
+  for (const entry of entries) {
+    const fileName = encodeUtf8(entry.path);
+    const localHeader = createByteBuffer(30 + fileName.length);
+    const localHeaderView = new DataView(localHeader.buffer);
+    localHeaderView.setUint32(0, 67324752, true);
+    localHeaderView.setUint16(4, 20, true);
+    localHeaderView.setUint16(6, 0, true);
+    localHeaderView.setUint16(8, entry.compression === "store" ? 0 : 8, true);
+    localHeaderView.setUint16(10, 0, true);
+    localHeaderView.setUint16(12, 0, true);
+    localHeaderView.setUint32(14, entry.crc32 >>> 0, true);
+    localHeaderView.setUint32(18, entry.compressedBytes.byteLength, true);
+    localHeaderView.setUint32(22, entry.uncompressedBytes.byteLength, true);
+    localHeaderView.setUint16(26, fileName.length, true);
+    localHeaderView.setUint16(28, 0, true);
+    localHeader.set(fileName, 30);
+    localChunks.push(localHeader, entry.compressedBytes);
+    const centralHeader = createByteBuffer(46 + fileName.length);
+    const centralHeaderView = new DataView(centralHeader.buffer);
+    centralHeaderView.setUint32(0, 33639248, true);
+    centralHeaderView.setUint16(4, 20, true);
+    centralHeaderView.setUint16(6, 20, true);
+    centralHeaderView.setUint16(8, 0, true);
+    centralHeaderView.setUint16(10, entry.compression === "store" ? 0 : 8, true);
+    centralHeaderView.setUint16(12, 0, true);
+    centralHeaderView.setUint16(14, 0, true);
+    centralHeaderView.setUint32(16, entry.crc32 >>> 0, true);
+    centralHeaderView.setUint32(20, entry.compressedBytes.byteLength, true);
+    centralHeaderView.setUint32(24, entry.uncompressedBytes.byteLength, true);
+    centralHeaderView.setUint16(28, fileName.length, true);
+    centralHeaderView.setUint16(30, 0, true);
+    centralHeaderView.setUint16(32, 0, true);
+    centralHeaderView.setUint16(34, 0, true);
+    centralHeaderView.setUint16(36, 0, true);
+    centralHeaderView.setUint32(38, 0, true);
+    centralHeaderView.setUint32(42, localOffset, true);
+    centralHeader.set(fileName, 46);
+    centralChunks.push(centralHeader);
+    localOffset += localHeader.byteLength + entry.compressedBytes.byteLength;
+  }
+  const centralDirectoryOffset = localOffset;
+  const centralDirectory = concatByteArrays(centralChunks);
+  const endOfCentralDirectory = createByteBuffer(22);
+  const endOfCentralDirectoryView = new DataView(endOfCentralDirectory.buffer);
+  endOfCentralDirectoryView.setUint32(0, 101010256, true);
+  endOfCentralDirectoryView.setUint16(4, 0, true);
+  endOfCentralDirectoryView.setUint16(6, 0, true);
+  endOfCentralDirectoryView.setUint16(8, entries.length, true);
+  endOfCentralDirectoryView.setUint16(10, entries.length, true);
+  endOfCentralDirectoryView.setUint32(12, centralDirectory.byteLength, true);
+  endOfCentralDirectoryView.setUint32(16, centralDirectoryOffset, true);
+  endOfCentralDirectoryView.setUint16(20, 0, true);
+  return concatByteArrays([...localChunks, centralDirectory, endOfCentralDirectory]);
+}
+function encodeXml(xml) {
+  return encodeUtf8(xml);
+}
+function escapeXml(value) {
+  return value.replace(/&/g, "&amp;").replace(/"/g, "&quot;").replace(/</g, "&lt;").replace(/>/g, "&gt;").replace(/'/g, "&apos;");
+}
+function calculateCrc32(bytes) {
+  let crc = 4294967295;
+  for (const byte of bytes) {
+    crc ^= byte;
+    for (let bit = 0; bit < 8; bit += 1) {
+      const mask = -(crc & 1);
+      crc = crc >>> 1 ^ 3988292384 & mask;
+    }
+  }
+  return (crc ^ 4294967295) >>> 0;
+}
+function createByteBuffer(size) {
+  return new Uint8Array(size);
+}
+function concatByteArrays(chunks) {
+  const totalLength = chunks.reduce((sum, chunk) => sum + chunk.byteLength, 0);
+  const combined = new Uint8Array(totalLength);
+  let offset = 0;
+  for (const chunk of chunks) {
+    combined.set(chunk, offset);
+    offset += chunk.byteLength;
+  }
+  return combined;
+}
+function encodeUtf8(value) {
+  return new TextEncoder().encode(value);
+}
+
+// src/io/opc/docx-package.ts
+var DOCX_MIME_TYPE = "application/vnd.openxmlformats-officedocument.wordprocessingml.document";
+var DOCX_DOCUMENT_CONTENT_TYPE = "application/vnd.openxmlformats-officedocument.wordprocessingml.document.main+xml";
+var DOCX_DOCUMENT_RELATIONSHIP_TYPE = "http://schemas.openxmlformats.org/officeDocument/2006/relationships/officeDocument";
+function writeDocxPackage(input) {
+  const documentPath = "/word/document.xml";
+  const contentType = input.documentContentType ?? DOCX_DOCUMENT_CONTENT_TYPE;
+  const relationshipType = input.packageRelationshipType ?? DOCX_DOCUMENT_RELATIONSHIP_TYPE;
+  const documentBytes = new TextEncoder().encode(input.documentXml);
+  const documentPart = {
+    path: documentPath,
+    surfaceKind: "content",
+    contentType,
+    relationshipsPartPath: getRelationshipsPartPath(documentPath),
+    relationships: [],
+    compression: "deflate",
+    bytes: documentBytes,
+    crc32: 0
+  };
+  const manifest = {
+    contentTypes: {
+      defaults: {
+        rels: "application/vnd.openxmlformats-package.relationships+xml",
+        xml: "application/xml"
+      },
+      overrides: {
+        [documentPath]: contentType
+      }
+    },
+    packageRelationships: [
+      {
+        id: "rId1",
+        type: relationshipType,
+        target: "word/document.xml",
+        targetMode: "internal"
+      }
+    ],
+    parts: [
+      {
+        path: documentPart.path,
+        surfaceKind: documentPart.surfaceKind,
+        contentType: documentPart.contentType,
+        relationshipsPartPath: documentPart.relationshipsPartPath,
+        relationships: documentPart.relationships,
+        compression: documentPart.compression,
+        byteLength: documentPart.bytes.byteLength
+      }
+    ]
+  };
+  return writeOpcPackage({
+    manifest,
+    parts: /* @__PURE__ */ new Map([[documentPart.path, documentPart]])
+  });
+}
+
+// src/io/opc/package-reader.ts
+import { inflateSync } from "fflate";
+var EOCD_SIGNATURE = 101010256;
+var CENTRAL_DIRECTORY_SIGNATURE = 33639248;
+var LOCAL_FILE_HEADER_SIGNATURE = 67324752;
+function readOpcPackage(source) {
+  const bytes = source instanceof Uint8Array ? source : new Uint8Array(source);
+  const centralDirectory = readCentralDirectory(bytes);
+  const parts = /* @__PURE__ */ new Map();
+  for (const entry of centralDirectory) {
+    if (entry.path.endsWith("/")) {
+      continue;
+    }
+    const storedBytes = readZipEntry(bytes, entry);
+    const normalizedPath = normalizePartPath(entry.path);
+    const surfaceKind = getSurfaceKind(normalizedPath);
+    parts.set(normalizedPath, {
+      path: normalizedPath,
+      surfaceKind,
+      contentType: null,
+      relationshipsPartPath: surfaceKind === "content" ? getRelationshipsPartPath(normalizedPath) : null,
+      relationships: [],
+      compression: entry.compression,
+      bytes: storedBytes,
+      crc32: entry.crc32 >>> 0
+    });
+  }
+  const contentTypesPart = parts.get(CONTENT_TYPES_PATH);
+  if (!contentTypesPart) {
+    throw new Error("Invalid OPC package: missing /[Content_Types].xml.");
+  }
+  const contentTypes = parseContentTypesXml(decodeXml(contentTypesPart.bytes));
+  const packageRelationshipsPart = parts.get(PACKAGE_RELATIONSHIPS_PATH);
+  const packageRelationships = packageRelationshipsPart ? parseRelationshipsXml(decodeXml(packageRelationshipsPart.bytes)) : [];
+  const manifestParts = [];
+  for (const [path, part] of [...parts.entries()].sort(([left], [right]) => left.localeCompare(right))) {
+    const contentType = resolveContentType(path, contentTypes);
+    const relationshipsPartPath = part.surfaceKind === "content" ? getRelationshipsPartPath(path) : null;
+    const relationshipsPart = relationshipsPartPath ? parts.get(relationshipsPartPath) : void 0;
+    const relationships = relationshipsPart ? parseRelationshipsXml(decodeXml(relationshipsPart.bytes)) : [];
+    const nextPart = {
+      ...part,
+      contentType,
+      relationshipsPartPath,
+      relationships
+    };
+    parts.set(path, nextPart);
+    manifestParts.push({
+      path,
+      surfaceKind: nextPart.surfaceKind,
+      contentType,
+      relationshipsPartPath,
+      relationships,
+      compression: nextPart.compression,
+      byteLength: nextPart.bytes.byteLength
+    });
+  }
+  return {
+    manifest: {
+      contentTypes,
+      packageRelationships,
+      parts: manifestParts
+    },
+    parts,
+    sourceByteLength: bytes.byteLength
+  };
+}
+function readCentralDirectory(archive) {
+  const view = new DataView(archive.buffer, archive.byteOffset, archive.byteLength);
+  const eocdOffset = findEndOfCentralDirectory(archive, view);
+  const entryCount = view.getUint16(eocdOffset + 10, true);
+  const centralDirectoryOffset = view.getUint32(eocdOffset + 16, true);
+  const entries = [];
+  let offset = centralDirectoryOffset;
+  for (let index = 0; index < entryCount; index += 1) {
+    const signature = view.getUint32(offset, true);
+    if (signature !== CENTRAL_DIRECTORY_SIGNATURE) {
+      throw new Error(`Invalid ZIP central directory signature at offset ${offset}.`);
+    }
+    const generalPurposeBitFlag = view.getUint16(offset + 8, true);
+    const compressionMethod = view.getUint16(offset + 10, true);
+    const crc32 = view.getUint32(offset + 16, true);
+    const compressedSize = view.getUint32(offset + 20, true);
+    const uncompressedSize = view.getUint32(offset + 24, true);
+    const fileNameLength = view.getUint16(offset + 28, true);
+    const extraFieldLength = view.getUint16(offset + 30, true);
+    const fileCommentLength = view.getUint16(offset + 32, true);
+    const localHeaderOffset = view.getUint32(offset + 42, true);
+    const fileNameOffset = offset + 46;
+    const fileName = decodeUtf8(archive.subarray(fileNameOffset, fileNameOffset + fileNameLength));
+    entries.push({
+      path: fileName,
+      compression: mapCompressionMethod(compressionMethod),
+      crc32,
+      compressedSize,
+      uncompressedSize,
+      localHeaderOffset,
+      generalPurposeBitFlag
+    });
+    offset += 46 + fileNameLength + extraFieldLength + fileCommentLength;
+  }
+  return entries;
+}
+function findEndOfCentralDirectory(archive, view) {
+  const minimumEocdSize = 22;
+  const maximumCommentSize = 65535;
+  const searchStart = Math.max(0, archive.length - minimumEocdSize - maximumCommentSize);
+  for (let offset = archive.length - minimumEocdSize; offset >= searchStart; offset -= 1) {
+    if (view.getUint32(offset, true) === EOCD_SIGNATURE) {
+      return offset;
+    }
+  }
+  throw new Error("Invalid ZIP archive: end of central directory not found.");
+}
+function readZipEntry(archive, entry) {
+  const view = new DataView(archive.buffer, archive.byteOffset, archive.byteLength);
+  const headerOffset = entry.localHeaderOffset;
+  const signature = view.getUint32(headerOffset, true);
+  if (signature !== LOCAL_FILE_HEADER_SIGNATURE) {
+    throw new Error(`Invalid ZIP local file header signature at offset ${headerOffset}.`);
+  }
+  const fileNameLength = view.getUint16(headerOffset + 26, true);
+  const extraFieldLength = view.getUint16(headerOffset + 28, true);
+  const dataOffset = headerOffset + 30 + fileNameLength + extraFieldLength;
+  const compressed = archive.subarray(dataOffset, dataOffset + entry.compressedSize);
+  switch (entry.compression) {
+    case "store":
+      return new Uint8Array(compressed);
+    case "deflate":
+      return inflateSync(compressed);
+    default:
+      throw new Error(`Unsupported ZIP compression for ${entry.path}.`);
+  }
+}
+function mapCompressionMethod(method) {
+  switch (method) {
+    case 0:
+      return "store";
+    case 8:
+      return "deflate";
+    default:
+      throw new Error(`Unsupported ZIP compression method ${method}.`);
+  }
+}
+function getSurfaceKind(path) {
+  if (path === CONTENT_TYPES_PATH) {
+    return "content-types";
+  }
+  if (path === PACKAGE_RELATIONSHIPS_PATH || path.includes("/_rels/")) {
+    return "relationships";
+  }
+  return "content";
+}
+function decodeXml(bytes) {
+  return new TextDecoder("utf-8").decode(bytes);
+}
+function decodeUtf8(bytes) {
+  return new TextDecoder("utf-8").decode(bytes);
+}
+function parseContentTypesXml(xml) {
+  const defaults = {};
+  const overrides = {};
+  for (const attributes of findTagAttributes(xml, "Default")) {
+    const extension = attributes.Extension?.toLowerCase();
+    const contentType = attributes.ContentType;
+    if (!extension || !contentType) {
+      continue;
+    }
+    defaults[extension] = contentType;
+  }
+  for (const attributes of findTagAttributes(xml, "Override")) {
+    const partName = attributes.PartName;
+    const contentType = attributes.ContentType;
+    if (!partName || !contentType) {
+      continue;
+    }
+    overrides[normalizePartPath(partName)] = contentType;
+  }
+  return { defaults, overrides };
+}
+function parseRelationshipsXml(xml) {
+  const relationships = [];
+  for (const attributes of findTagAttributes(xml, "Relationship")) {
+    const id = attributes.Id;
+    const type = attributes.Type;
+    const target = attributes.Target;
+    if (!id || !type || !target) {
+      continue;
+    }
+    relationships.push({
+      id,
+      type,
+      target,
+      targetMode: attributes.TargetMode === "External" ? "external" : "internal"
+    });
+  }
+  return relationships;
+}
+function findTagAttributes(xml, tagName) {
+  const tagPattern = new RegExp(`<(?:[A-Za-z_][\\w.-]*:)?${tagName}\\b([^>]*)\\/?>`, "g");
+  const results = [];
+  let tagMatch = tagPattern.exec(xml);
+  while (tagMatch) {
+    results.push(parseAttributes(tagMatch[1] ?? ""));
+    tagMatch = tagPattern.exec(xml);
+  }
+  return results;
+}
+function parseAttributes(rawAttributes) {
+  const attributes = {};
+  const attributePattern = /([A-Za-z_][\w:.-]*)\s*=\s*(["'])([\s\S]*?)\2/g;
+  let match = attributePattern.exec(rawAttributes);
+  while (match) {
+    attributes[match[1]] = decodeXmlEntities(match[3]);
+    match = attributePattern.exec(rawAttributes);
+  }
+  return attributes;
+}
+function decodeXmlEntities(value) {
+  return value.replace(/&quot;/g, '"').replace(/&apos;/g, "'").replace(/&lt;/g, "<").replace(/&gt;/g, ">").replace(/&amp;/g, "&");
+}
+function resolveContentType(path, contentTypes) {
+  if (path === CONTENT_TYPES_PATH) {
+    return "application/xml";
+  }
+  const override = contentTypes.overrides[path];
+  if (override) {
+    return override;
+  }
+  const extension = path.includes(".") ? path.slice(path.lastIndexOf(".") + 1).toLowerCase() : "";
+  return extension ? contentTypes.defaults[extension] ?? null : null;
+}
+
+// src/io/export/reattach-preserved-parts.ts
+function reattachPreservedParts(sourcePackage, workingParts, packageRelationships, ownedPaths) {
+  for (const [path, sourcePart] of sourcePackage.parts.entries()) {
+    if (ownedPaths.has(path) || sourcePart.surfaceKind !== "content") {
+      continue;
+    }
+    if (!workingParts.has(path)) {
+      workingParts.set(path, clonePart(sourcePart));
+      continue;
+    }
+    const currentPart = workingParts.get(path);
+    if (!currentPart) {
+      continue;
+    }
+    currentPart.contentType = sourcePart.contentType;
+    currentPart.relationships = sourcePart.relationships.map(cloneRelationship);
+    currentPart.relationshipsPartPath = sourcePart.relationshipsPartPath;
+    currentPart.compression = sourcePart.compression;
+    currentPart.bytes = new Uint8Array(sourcePart.bytes);
+    currentPart.crc32 = sourcePart.crc32;
+  }
+  const knownPackageRelationshipIds = new Set(packageRelationships.map((relationship) => relationship.id));
+  for (const relationship of sourcePackage.manifest.packageRelationships) {
+    if (knownPackageRelationshipIds.has(relationship.id)) {
+      continue;
+    }
+    packageRelationships.push(cloneRelationship(relationship));
+    knownPackageRelationshipIds.add(relationship.id);
+  }
+}
+function clonePart(part) {
+  return {
+    ...part,
+    relationships: part.relationships.map(cloneRelationship),
+    bytes: new Uint8Array(part.bytes)
+  };
+}
+function cloneRelationship(relationship) {
+  return { ...relationship };
+}
+
+// src/io/export/export-session.ts
+var ExportSession = class {
+  constructor(sourcePackage, ownedOutputPaths) {
+    this.sourcePackage = sourcePackage;
+    this.ownedPaths = new Set(
+      [...ownedOutputPaths].map((path) => {
+        const normalized = normalizePartPath(path);
+        if (normalized === CONTENT_TYPES_PATH || normalized.endsWith(".rels") || normalized === PACKAGE_RELATIONSHIPS_PATH) {
+          throw new Error(`ExportSession cannot directly own reserved OPC manifest path ${normalized}.`);
+        }
+        return normalized;
+      })
+    );
+    this.workingParts = cloneParts(sourcePackage.parts);
+    this.packageRelationships = sourcePackage.manifest.packageRelationships.map(cloneRelationship2);
+  }
+  ownedPaths;
+  workingParts;
+  packageRelationships;
+  replaceOwnedPart(replacement) {
+    const normalizedPath = normalizePartPath(replacement.path);
+    if (!this.ownedPaths.has(normalizedPath)) {
+      throw new Error(`Attempted to rewrite non-owned OPC path ${normalizedPath}.`);
+    }
+    const existing = this.workingParts.get(normalizedPath);
+    const nextPart = {
+      path: normalizedPath,
+      surfaceKind: "content",
+      contentType: replacement.contentType,
+      relationshipsPartPath: getRelationshipsPartPath(normalizedPath),
+      relationships: (replacement.relationships ?? existing?.relationships ?? []).map(cloneRelationship2),
+      compression: replacement.compression ?? existing?.compression ?? "deflate",
+      bytes: new Uint8Array(replacement.bytes),
+      crc32: 0
+    };
+    this.workingParts.set(normalizedPath, nextPart);
+  }
+  withOwnedPart(replacement) {
+    this.replaceOwnedPart(replacement);
+    return this;
+  }
+  ensurePackageRelationship(input) {
+    const targetMode = input.targetMode ?? "internal";
+    const normalizedTarget = targetMode === "internal" ? normalizePartPath(input.target) : input.target;
+    const existing = this.packageRelationships.find((relationship) => {
+      if (relationship.type !== input.type || relationship.targetMode !== targetMode) {
+        return false;
+      }
+      return targetMode === "internal" ? resolveRelationshipTarget(null, relationship) === normalizedTarget : relationship.target === normalizedTarget;
+    });
+    if (existing) {
+      return;
+    }
+    const relationshipId = createUniqueRelationshipId(
+      new Set(this.packageRelationships.map((relationship) => relationship.id)),
+      input.preferredId ?? "rIdPackage1"
+    );
+    this.packageRelationships.push({
+      id: relationshipId,
+      type: input.type,
+      target: targetMode === "internal" ? toPackageRelationshipTarget(normalizedTarget) : normalizedTarget,
+      targetMode
+    });
+  }
+  toPackage() {
+    reattachPreservedParts(
+      this.sourcePackage,
+      this.workingParts,
+      this.packageRelationships,
+      this.ownedPaths
+    );
+    const parts = pruneReservedManifestParts(this.workingParts);
+    const manifest = buildManifest(parts, this.packageRelationships, this.sourcePackage.manifest.contentTypes);
+    return {
+      manifest,
+      parts,
+      sourceByteLength: this.sourcePackage.sourceByteLength
+    };
+  }
+  serialize() {
+    return writeOpcPackage(this.toPackage());
+  }
+};
+function createExportSession(sourcePackage, ownedOutputPaths) {
+  return new ExportSession(sourcePackage, ownedOutputPaths);
+}
+function cloneParts(parts) {
+  return new Map(
+    [...parts.entries()].map(([path, part]) => [
+      path,
+      {
+        ...part,
+        relationships: part.relationships.map(cloneRelationship2),
+        bytes: new Uint8Array(part.bytes)
+      }
+    ])
+  );
+}
+function pruneReservedManifestParts(parts) {
+  return new Map(
+    [...parts.entries()].filter(([path]) => path !== CONTENT_TYPES_PATH && path !== PACKAGE_RELATIONSHIPS_PATH && !path.includes("/_rels/"))
+  );
+}
+function buildManifest(parts, packageRelationships, contentTypesSeed) {
+  const partsList = [...parts.values()].sort((left, right) => comparePartPaths(left.path, right.path));
+  const overrides = { ...contentTypesSeed.overrides };
+  for (const key of Object.keys(overrides)) {
+    if (!parts.has(normalizePartPath(key))) {
+      delete overrides[key];
+    }
+  }
+  for (const part of partsList) {
+    if (!part.contentType) {
+      throw new Error(`Cannot export part without content type: ${part.path}`);
+    }
+    overrides[part.path] = part.contentType;
+  }
+  return {
+    contentTypes: {
+      defaults: { ...contentTypesSeed.defaults },
+      overrides
+    },
+    packageRelationships: packageRelationships.map(cloneRelationship2),
+    parts: partsList.map((part) => ({
+      path: part.path,
+      surfaceKind: part.surfaceKind,
+      contentType: part.contentType,
+      relationshipsPartPath: part.relationshipsPartPath,
+      relationships: part.relationships.map(cloneRelationship2),
+      compression: part.compression,
+      byteLength: part.bytes.byteLength
+    }))
+  };
+}
+function cloneRelationship2(relationship) {
+  return { ...relationship };
+}
+function createUniqueRelationshipId(existingIds, preferredId) {
+  if (!existingIds.has(preferredId)) {
+    return preferredId;
+  }
+  let nextIndex = 2;
+  while (existingIds.has(`${preferredId}-${nextIndex}`)) {
+    nextIndex += 1;
+  }
+  return `${preferredId}-${nextIndex}`;
+}
+function toPackageRelationshipTarget(partPath) {
+  return normalizePartPath(partPath).slice(1);
+}
+
+// src/io/ooxml/numbering-sentinels.ts
+var DOCX_NULL_NUMBERING_INSTANCE_ID = "num:0";
+var DOCX_NULL_ABSTRACT_NUMBERING_ID = "abstract-num:__docx-import-null__";
+function createSyntheticDocxNullNumberingCatalog() {
+  return {
+    abstractDefinitions: {
+      [DOCX_NULL_ABSTRACT_NUMBERING_ID]: {
+        abstractNumberingId: DOCX_NULL_ABSTRACT_NUMBERING_ID,
+        levels: Array.from({ length: 9 }, (_unused, level) => ({
+          level,
+          format: "none",
+          text: ""
+        }))
+      }
+    },
+    instances: {
+      [DOCX_NULL_NUMBERING_INSTANCE_ID]: {
+        numberingInstanceId: DOCX_NULL_NUMBERING_INSTANCE_ID,
+        abstractNumberingId: DOCX_NULL_ABSTRACT_NUMBERING_ID,
+        overrides: []
+      }
+    }
+  };
+}
+function isSyntheticDocxNullAbstractDefinition(definition) {
+  return definition.abstractNumberingId === DOCX_NULL_ABSTRACT_NUMBERING_ID;
+}
+function isSyntheticDocxNullNumberingInstance(instance) {
+  return instance.numberingInstanceId === DOCX_NULL_NUMBERING_INSTANCE_ID && instance.abstractNumberingId === DOCX_NULL_ABSTRACT_NUMBERING_ID;
+}
+
+// src/io/export/serialize-numbering.ts
+var WORD_NUMBERING_CONTENT_TYPE = "application/vnd.openxmlformats-officedocument.wordprocessingml.numbering+xml";
+function serializeNumberingXml(catalog) {
+  const abstractDefinitions = Object.values(catalog.abstractDefinitions).filter((definition) => !isSyntheticDocxNullAbstractDefinition(definition)).sort(
+    (left, right) => compareSerializedIds(left.abstractNumberingId, right.abstractNumberingId)
+  );
+  const instances = Object.values(catalog.instances).filter((instance) => !isSyntheticDocxNullNumberingInstance(instance)).sort(
+    (left, right) => compareSerializedIds(left.numberingInstanceId, right.numberingInstanceId)
+  );
+  const body = [
+    ...abstractDefinitions.map((definition) => serializeAbstractDefinition(definition)),
+    ...instances.map((instance) => serializeInstance(instance))
+  ].join("");
+  return [
+    `<?xml version="1.0" encoding="UTF-8" standalone="yes"?>`,
+    `<w:numbering xmlns:w="http://schemas.openxmlformats.org/wordprocessingml/2006/main">${body}</w:numbering>`
+  ].join("\n");
+}
+function hasSerializableNumberingEntries(catalog) {
+  return Object.values(catalog.abstractDefinitions).some(
+    (definition) => !isSyntheticDocxNullAbstractDefinition(definition)
+  ) || Object.values(catalog.instances).some(
+    (instance) => !isSyntheticDocxNullNumberingInstance(instance)
+  );
+}
+function serializeParagraphNumberingProperties(numbering) {
+  if (!numbering) {
+    return "";
+  }
+  return `<w:numPr><w:ilvl w:val="${numbering.level}"/><w:numId w:val="${escapeAttribute(
+    stripCanonicalPrefix(numbering.numberingInstanceId, "num:")
+  )}"/></w:numPr>`;
+}
+function serializeAbstractDefinition(definition) {
+  const abstractNumId = escapeAttribute(
+    stripCanonicalPrefix(definition.abstractNumberingId, "abstract-num:")
+  );
+  const levels = [...definition.levels].sort((left, right) => left.level - right.level).map((level) => serializeLevel(level)).join("");
+  return `<w:abstractNum w:abstractNumId="${abstractNumId}">${levels}</w:abstractNum>`;
+}
+function serializeLevel(level) {
+  const start = level.startAt !== void 0 ? `<w:start w:val="${level.startAt}"/>` : "";
+  const paragraphStyle = level.paragraphStyleId ? `<w:pStyle w:val="${escapeAttribute(level.paragraphStyleId)}"/>` : "";
+  const isLegal = level.isLegalNumbering ? "<w:isLgl/>" : "";
+  const suffix = level.suffix ? `<w:suff w:val="${escapeAttribute(level.suffix)}"/>` : "";
+  return `<w:lvl w:ilvl="${level.level}">${start}<w:numFmt w:val="${escapeAttribute(
+    level.format
+  )}"/><w:lvlText w:val="${escapeAttribute(level.text)}"/>${paragraphStyle}${isLegal}${suffix}</w:lvl>`;
+}
+function serializeInstance(instance) {
+  const numId = escapeAttribute(stripCanonicalPrefix(instance.numberingInstanceId, "num:"));
+  const abstractNumId = escapeAttribute(
+    stripCanonicalPrefix(instance.abstractNumberingId, "abstract-num:")
+  );
+  const overrides = [...instance.overrides].sort((left, right) => left.level - right.level).map((override) => serializeOverride(override)).join("");
+  return `<w:num w:numId="${numId}"><w:abstractNumId w:val="${abstractNumId}"/>${overrides}</w:num>`;
+}
+function serializeOverride(override) {
+  const startOverride = override.startAt !== void 0 ? `<w:startOverride w:val="${override.startAt}"/>` : "";
+  return `<w:lvlOverride w:ilvl="${override.level}">${startOverride}</w:lvlOverride>`;
+}
+function compareSerializedIds(left, right) {
+  return stripKnownPrefix(left).localeCompare(stripKnownPrefix(right), "en", { numeric: true });
+}
+function stripKnownPrefix(value) {
+  return value.replace(/^abstract-num:|^num:/, "");
+}
+function stripCanonicalPrefix(value, prefix) {
+  return value.startsWith(prefix) ? value.slice(prefix.length) : value;
+}
+function escapeAttribute(value) {
+  return value.replace(/&/g, "&amp;").replace(/"/g, "&quot;").replace(/</g, "&lt;").replace(/>/g, "&gt;");
+}
+
+// src/preservation/relationship-retention.ts
+function retainRelationshipsForFragment(fragment, relationships, existingRelationshipMap, retainedRelationshipIds) {
+  if (!fragment || fragment.payloadKind !== "xml-subtree") {
+    return;
+  }
+  for (const relationshipId of extractReferencedRelationshipIds(fragment.payloadReference)) {
+    if (retainedRelationshipIds.has(relationshipId)) {
+      continue;
+    }
+    const relationship = existingRelationshipMap.get(relationshipId);
+    if (!relationship) {
+      continue;
+    }
+    relationships.push({ ...relationship });
+    retainedRelationshipIds.add(relationshipId);
+  }
+}
+function extractReferencedRelationshipIds(xml) {
+  const relationshipIds = /* @__PURE__ */ new Set();
+  const relationshipPattern = /\br:id=(["'])([^"']+)\1/gu;
+  for (const match of xml.matchAll(relationshipPattern)) {
+    const relationshipId = match[2];
+    if (relationshipId) {
+      relationshipIds.add(relationshipId);
+    }
+  }
+  return relationshipIds;
+}
+
+// src/io/export/serialize-main-document.ts
+var HYPERLINK_RELATIONSHIP_TYPE = "http://schemas.openxmlformats.org/officeDocument/2006/relationships/hyperlink";
+function serializeMainDocument(content, preservation = { opaqueFragments: {}, packageParts: {} }, existingRelationships = [], options = {}) {
+  const nextRelationshipIndex = existingRelationships.reduce((maxIndex, relationship) => {
+    const match = /^rIdHyperlink(\d+)$/.exec(relationship.id);
+    return match ? Math.max(maxIndex, Number.parseInt(match[1] ?? "0", 10)) : maxIndex;
+  }, 0) + 1;
+  const state = {
+    nextHyperlinkRelationshipIndex: nextRelationshipIndex,
+    relationships: existingRelationships.filter(
+      (relationship) => relationship.type !== HYPERLINK_RELATIONSHIP_TYPE
+    ).map(cloneRelationship3),
+    existingRelationshipMap: new Map(
+      existingRelationships.map((relationship) => [relationship.id, cloneRelationship3(relationship)])
+    ),
+    retainedRelationshipIds: new Set(
+      existingRelationships.filter((relationship) => relationship.type !== HYPERLINK_RELATIONSHIP_TYPE).map((relationship) => relationship.id)
+    ),
+    media: options.media ?? { items: {} },
+    preservation
+  };
+  const documentOpen = `<w:document${serializeDocumentAttributes(options.documentAttributes, content)}>`;
+  const prefix = [
+    `<?xml version="1.0" encoding="UTF-8" standalone="yes"?>`,
+    documentOpen,
+    `  <w:body>`
+  ].join("\n");
+  const suffix = `</w:body>
+</w:document>`;
+  const bodyPieces = [];
+  const paragraphBoundaries = [];
+  let bodyLength = 0;
+  let sectionPropertiesXml = options.finalSectionProperties ? serializeSectionPropertiesXml(options.finalSectionProperties) : "<w:sectPr/>";
+  let cursor = 0;
+  let paragraphIndex = -1;
+  let previousWasParagraph = false;
+  for (const block of content.children) {
+    if (block.type === "paragraph") {
+      if (previousWasParagraph) {
+        cursor += 1;
+      }
+      paragraphIndex += 1;
+      const serializedParagraph = serializeParagraph(
+        block,
+        state,
+        cursor,
+        paragraphIndex
+      );
+      const paragraphOffset = prefix.length + bodyLength;
+      bodyPieces.push(serializedParagraph.xml);
+      bodyLength += serializedParagraph.xml.length;
+      paragraphBoundaries.push(
+        offsetParagraphBoundary(serializedParagraph.boundary, paragraphOffset)
+      );
+      cursor = serializedParagraph.nextCursor;
+      previousWasParagraph = true;
+      continue;
+    }
+    if (block.type === "table") {
+      const tableXml = serializeTableNode(block, state);
+      bodyPieces.push(tableXml);
+      bodyLength += tableXml.length;
+      cursor += 1;
+      previousWasParagraph = false;
+      continue;
+    }
+    if (block.type === "sdt") {
+      const sdtXml = serializeSdtNode(block, state);
+      bodyPieces.push(sdtXml);
+      bodyLength += sdtXml.length;
+      previousWasParagraph = false;
+      continue;
+    }
+    if (block.type === "custom_xml") {
+      const customXml = serializeCustomXmlNode(block, state);
+      bodyPieces.push(customXml);
+      bodyLength += customXml.length;
+      previousWasParagraph = false;
+      continue;
+    }
+    if (block.type === "alt_chunk") {
+      const altChunkXml = serializeAltChunkNode(block);
+      bodyPieces.push(altChunkXml);
+      bodyLength += altChunkXml.length;
+      cursor += 1;
+      previousWasParagraph = false;
+      continue;
+    }
+    if (block.type === "section_break") {
+      let inlineSectPr;
+      if (block.sectionPropertiesXml ?? block.propertiesXml) {
+        inlineSectPr = block.sectionPropertiesXml ?? block.propertiesXml;
+      } else if (block.sectionProperties) {
+        inlineSectPr = serializeSectionPropertiesXml(block.sectionProperties);
+      } else {
+        inlineSectPr = "<w:sectPr/>";
+      }
+      const sectionParagraphXml = `<w:p><w:pPr>${inlineSectPr}</w:pPr></w:p>`;
+      bodyPieces.push(sectionParagraphXml);
+      bodyLength += sectionParagraphXml.length;
+      cursor += 1;
+      previousWasParagraph = false;
+      continue;
+    }
+    const blockXml = serializeOpaqueBlock(block, state);
+    if (looksLikeSectionPropertiesXml(blockXml)) {
+      sectionPropertiesXml = blockXml;
+    } else {
+      bodyPieces.push(blockXml);
+      bodyLength += blockXml.length;
+    }
+    cursor += 1;
+    previousWasParagraph = false;
+  }
+  const bodyXml = bodyPieces.join("");
+  const documentXml = `${prefix}${bodyXml || "<w:p><w:r><w:t></w:t></w:r></w:p>"}${sectionPropertiesXml}${suffix}`;
+  return {
+    documentXml,
+    relationships: state.relationships,
+    paragraphBoundaries
+  };
+}
+function serializeOpaqueBlock(block, state) {
+  return lookupOpaqueXml(block.fragmentId, state);
+}
+function serializeTableNode(table, state) {
+  const propertiesXml = table.propertiesXml ?? buildTablePropertiesXml(table);
+  const gridXml = table.gridColumns.length > 0 ? `<w:tblGrid>${table.gridColumns.map((width) => `<w:gridCol w:w="${width}"/>`).join("")}</w:tblGrid>` : "";
+  const rowsXml = table.rows.map((row) => {
+    const rowPropertiesXml = row.propertiesXml ?? buildTableRowPropertiesXml(row);
+    const cellsXml = row.cells.map((cell) => serializeTableCellNode(cell, state)).join("");
+    return `<w:tr>${rowPropertiesXml}${cellsXml}</w:tr>`;
+  }).join("");
+  return `<w:tbl>${propertiesXml}${gridXml}${rowsXml}</w:tbl>`;
+}
+function serializeTableCellNode(cell, state) {
+  const propertiesXml = cell.propertiesXml ?? buildCellPropertiesXml(cell);
+  const blocksXml = cell.children.map((child) => serializeBlockNode(child, state)).join("");
+  return `<w:tc>${propertiesXml}${blocksXml || "<w:p/>"}</w:tc>`;
+}
+function serializeBlockNode(block, state) {
+  switch (block.type) {
+    case "paragraph":
+      return serializeTableCellParagraph(block, state);
+    case "table":
+      return serializeTableNode(block, state);
+    case "sdt":
+      return serializeSdtNode(block, state);
+    case "custom_xml":
+      return serializeCustomXmlNode(block, state);
+    case "alt_chunk":
+      return serializeAltChunkNode(block);
+    case "opaque_block":
+      return lookupOpaqueXml(block.fragmentId, state);
+    case "section_break":
+      if (block.sectionPropertiesXml ?? block.propertiesXml) {
+        return block.sectionPropertiesXml ?? block.propertiesXml;
+      }
+      if (block.sectionProperties) return serializeSectionPropertiesXml(block.sectionProperties);
+      return "<w:sectPr/>";
+  }
+}
+function buildCellPropertiesXml(cell) {
+  const children = [];
+  if (cell.gridSpan && cell.gridSpan > 1) {
+    children.push(`<w:gridSpan w:val="${cell.gridSpan}"/>`);
+  }
+  if (cell.verticalMerge) {
+    children.push(
+      cell.verticalMerge === "restart" ? `<w:vMerge w:val="restart"/>` : `<w:vMerge/>`
+    );
+  }
+  return children.length > 0 ? `<w:tcPr>${children.join("")}</w:tcPr>` : "";
+}
+function buildTableRowPropertiesXml(row) {
+  const children = [];
+  if (row.gridBefore !== void 0) {
+    children.push(`<w:gridBefore w:val="${row.gridBefore}"/>`);
+  }
+  if (row.widthBefore) {
+    children.push(`<w:wBefore w:w="${row.widthBefore.value}" w:type="${row.widthBefore.type}"/>`);
+  }
+  if (row.gridAfter !== void 0) {
+    children.push(`<w:gridAfter w:val="${row.gridAfter}"/>`);
+  }
+  if (row.widthAfter) {
+    children.push(`<w:wAfter w:w="${row.widthAfter.value}" w:type="${row.widthAfter.type}"/>`);
+  }
+  if (children.length === 0) {
+    return "";
+  }
+  return `<w:trPr>${children.join("")}</w:trPr>`;
+}
+function serializeSdtNode(block, state) {
+  const propertiesXml = block.properties.propertiesXml ?? buildSdtPropertiesXml(block);
+  const childrenXml = block.children.map((child) => serializeBlockNode(child, state)).join("") || "<w:p/>";
+  return `<w:sdt>${propertiesXml}<w:sdtContent>${childrenXml}</w:sdtContent></w:sdt>`;
+}
+function serializeCustomXmlNode(block, state) {
+  const attrs = [];
+  if (block.uri) {
+    attrs.push(`w:uri="${escapeAttribute2(block.uri)}"`);
+  }
+  if (block.element) {
+    attrs.push(`w:element="${escapeAttribute2(block.element)}"`);
+  }
+  const attrXml = attrs.length > 0 ? ` ${attrs.join(" ")}` : "";
+  const childrenXml = block.children.map((child) => serializeBlockNode(child, state)).join("");
+  return `<w:customXml${attrXml}>${childrenXml || "<w:p/>"}</w:customXml>`;
+}
+function serializeAltChunkNode(block) {
+  return `<w:altChunk r:id="${escapeAttribute2(block.relationshipId)}"/>`;
+}
+function buildSdtPropertiesXml(block) {
+  const children = [];
+  if (block.properties.alias) {
+    children.push(`<w:alias w:val="${escapeAttribute2(block.properties.alias)}"/>`);
+  }
+  if (block.properties.tag) {
+    children.push(`<w:tag w:val="${escapeAttribute2(block.properties.tag)}"/>`);
+  }
+  if (block.properties.lock) {
+    children.push(`<w:lock w:val="${escapeAttribute2(block.properties.lock)}"/>`);
+  }
+  if (block.properties.showingPlcHdr) {
+    children.push(`<w:showingPlcHdr/>`);
+  }
+  if (block.properties.checkbox) {
+    const cb = block.properties.checkbox;
+    const cbParts = [];
+    cbParts.push(`<w14:checked w14:val="${cb.checked ? "1" : "0"}"/>`);
+    if (cb.checkedChar) cbParts.push(`<w14:checkedState w14:val="${escapeAttribute2(cb.checkedChar)}"/>`);
+    if (cb.uncheckedChar) cbParts.push(`<w14:uncheckedState w14:val="${escapeAttribute2(cb.uncheckedChar)}"/>`);
+    children.push(`<w14:checkbox>${cbParts.join("")}</w14:checkbox>`);
+  } else if (block.properties.datePicker) {
+    const dp = block.properties.datePicker;
+    const dateAttrs = dp.fullDate ? ` w:fullDate="${escapeAttribute2(dp.fullDate)}"` : "";
+    const dpParts = [];
+    if (dp.dateFormat) dpParts.push(`<w:dateFormat w:val="${escapeAttribute2(dp.dateFormat)}"/>`);
+    if (dp.lid) dpParts.push(`<w:lid w:val="${escapeAttribute2(dp.lid)}"/>`);
+    children.push(dpParts.length > 0 ? `<w:date${dateAttrs}>${dpParts.join("")}</w:date>` : `<w:date${dateAttrs}/>`);
+  } else if (block.properties.dropdownList) {
+    const items = block.properties.dropdownList.map((item) => {
+      const dt = item.displayText ? ` w:displayText="${escapeAttribute2(item.displayText)}"` : "";
+      return `<w:listItem${dt} w:value="${escapeAttribute2(item.value)}"/>`;
+    }).join("");
+    children.push(`<w:dropDownList>${items}</w:dropDownList>`);
+  } else if (block.properties.comboBox) {
+    const items = block.properties.comboBox.map((item) => {
+      const dt = item.displayText ? ` w:displayText="${escapeAttribute2(item.displayText)}"` : "";
+      return `<w:listItem${dt} w:value="${escapeAttribute2(item.value)}"/>`;
+    }).join("");
+    children.push(`<w:comboBox>${items}</w:comboBox>`);
+  } else if (block.properties.sdtType === "plainText") {
+    children.push(`<w:text/>`);
+  } else if (block.properties.sdtType === "richText") {
+    children.push(`<w:richText/>`);
+  } else if (block.properties.sdtType) {
+    children.push(`<w:${block.properties.sdtType}/>`);
+  }
+  return children.length > 0 ? `<w:sdtPr>${children.join("")}</w:sdtPr>` : "<w:sdtPr/>";
+}
+function serializeTableCellParagraph(paragraph, state) {
+  let xml = "<w:p>";
+  const paragraphPropertiesXml = buildParagraphPropertiesXml(paragraph);
+  if (paragraphPropertiesXml.length > 0) {
+    xml += paragraphPropertiesXml;
+  }
+  const childrenXml = paragraph.children.map((child) => serializeTableInlineNode(child, state)).join("");
+  xml += childrenXml || "<w:r><w:t></w:t></w:r>";
+  xml += "</w:p>";
+  return xml;
+}
+function serializeTableInlineNode(node, state) {
+  switch (node.type) {
+    case "text": {
+      const marks = node.marks;
+      const properties = serializeRunPropertiesFromMarks(marks);
+      const preserve = requiresPreservedSpace(node.text) ? ` xml:space="preserve"` : "";
+      return `<w:r>${properties}<w:t${preserve}>${escapeXml2(node.text)}</w:t></w:r>`;
+    }
+    case "tab":
+      return "<w:r><w:tab/></w:r>";
+    case "column_break":
+      return '<w:r><w:br w:type="column"/></w:r>';
+    case "hard_break":
+      return "<w:r><w:br/></w:r>";
+    case "symbol": {
+      const properties = serializeRunPropertiesFromMarks(node.marks);
+      const fontAttribute = node.font ? ` w:font="${escapeAttribute2(node.font)}"` : "";
+      return `<w:r>${properties}<w:sym${fontAttribute} w:char="${escapeAttribute2(node.char)}"/></w:r>`;
+    }
+    case "image":
+      return serializeImageNode(node, state);
+    case "opaque_inline":
+      return lookupOpaqueXml(node.fragmentId, state);
+    case "chart_preview":
+    case "smartart_preview":
+    case "shape":
+    case "wordart":
+    case "vml_shape":
+      return wrapInlineRawXml(node.rawXml);
+    case "hyperlink": {
+      const hyperlinkOpen = node.href.startsWith("#") ? `<w:hyperlink w:anchor="${escapeAttribute2(node.href.slice(1))}">` : (() => {
+        const relationshipId = `rIdHyperlink${state.nextHyperlinkRelationshipIndex}`;
+        state.nextHyperlinkRelationshipIndex += 1;
+        state.relationships.push({
+          id: relationshipId,
+          type: "http://schemas.openxmlformats.org/officeDocument/2006/relationships/hyperlink",
+          target: node.href,
+          targetMode: "external"
+        });
+        state.retainedRelationshipIds.add(relationshipId);
+        return `<w:hyperlink r:id="${relationshipId}">`;
+      })();
+      const childrenXml = node.children.map((child) => serializeTableInlineNode(child, state)).join("");
+      return `${hyperlinkOpen}${childrenXml}</w:hyperlink>`;
+    }
+    case "field": {
+      if (node.children && node.children.length > 0) {
+        const childrenXml = node.children.map((child) => serializeTableInlineNode(child, state)).join("");
+        if (node.fieldType === "complex") {
+          return `<w:r><w:fldChar w:fldCharType="begin"/></w:r><w:r><w:instrText xml:space="preserve"> ${escapeXml2(node.instruction)} </w:instrText></w:r><w:r><w:fldChar w:fldCharType="separate"/></w:r>` + childrenXml + `<w:r><w:fldChar w:fldCharType="end"/></w:r>`;
+        }
+        return `<w:fldSimple w:instr="${escapeAttribute2(node.instruction)}">${childrenXml}</w:fldSimple>`;
+      }
+      return `<w:fldSimple w:instr="${escapeAttribute2(node.instruction)}"/>`;
+    }
+    case "bookmark_start":
+      return `<w:bookmarkStart w:id="${escapeAttribute2(node.bookmarkId)}" w:name="${escapeAttribute2(node.name)}"/>`;
+    case "bookmark_end":
+      return `<w:bookmarkEnd w:id="${escapeAttribute2(node.bookmarkId)}"/>`;
+    case "footnote_ref": {
+      const refElement = node.noteKind === "footnote" ? `<w:footnoteReference w:id="${escapeAttribute2(node.noteId)}"/>` : `<w:endnoteReference w:id="${escapeAttribute2(node.noteId)}"/>`;
+      const styleVal = node.noteKind === "footnote" ? "FootnoteReference" : "EndnoteReference";
+      return `<w:r><w:rPr><w:rStyle w:val="${styleVal}"/></w:rPr>${refElement}</w:r>`;
+    }
+    default:
+      return "";
+  }
+}
+function buildParagraphPropertiesXml(paragraph) {
+  const children = [];
+  if (paragraph.styleId) {
+    children.push(`<w:pStyle w:val="${escapeAttribute2(paragraph.styleId)}"/>`);
+  }
+  if (paragraph.keepNext) {
+    children.push("<w:keepNext/>");
+  }
+  if (paragraph.keepLines) {
+    children.push("<w:keepLines/>");
+  }
+  if (paragraph.pageBreakBefore) {
+    children.push("<w:pageBreakBefore/>");
+  }
+  if (paragraph.widowControl) {
+    children.push("<w:widowControl/>");
+  }
+  if (paragraph.outlineLevel !== void 0) {
+    children.push(`<w:outlineLvl w:val="${paragraph.outlineLevel}"/>`);
+  }
+  if (paragraph.numbering) {
+    children.push(serializeParagraphNumberingProperties(paragraph.numbering));
+  }
+  if (paragraph.spacing) {
+    const s = paragraph.spacing;
+    const attrs = [];
+    if (s.before !== void 0) attrs.push(`w:before="${s.before}"`);
+    if (s.after !== void 0) attrs.push(`w:after="${s.after}"`);
+    if (s.line !== void 0) attrs.push(`w:line="${s.line}"`);
+    if (s.lineRule !== void 0) attrs.push(`w:lineRule="${s.lineRule}"`);
+    if (attrs.length > 0) children.push(`<w:spacing ${attrs.join(" ")}/>`);
+  }
+  if (paragraph.contextualSpacing !== void 0) {
+    children.push(
+      paragraph.contextualSpacing ? "<w:contextualSpacing/>" : `<w:contextualSpacing w:val="0"/>`
+    );
+  }
+  if (paragraph.indentation) {
+    const ind = paragraph.indentation;
+    const attrs = [];
+    if (ind.left !== void 0) attrs.push(`w:left="${ind.left}"`);
+    if (ind.right !== void 0) attrs.push(`w:right="${ind.right}"`);
+    if (ind.firstLine !== void 0) attrs.push(`w:firstLine="${ind.firstLine}"`);
+    if (ind.hanging !== void 0) attrs.push(`w:hanging="${ind.hanging}"`);
+    if (attrs.length > 0) children.push(`<w:ind ${attrs.join(" ")}/>`);
+  }
+  if (paragraph.alignment) {
+    children.push(`<w:jc w:val="${paragraph.alignment}"/>`);
+  }
+  if (paragraph.borders) {
+    const bordersXml = serializeParagraphBorders(paragraph.borders);
+    if (bordersXml) {
+      children.push(bordersXml);
+    }
+  }
+  if (paragraph.shading) {
+    const shadingXml = serializeParagraphShading(paragraph.shading);
+    if (shadingXml) {
+      children.push(shadingXml);
+    }
+  }
+  if (paragraph.bidi) {
+    children.push("<w:bidi/>");
+  }
+  if (paragraph.suppressLineNumbers) {
+    children.push("<w:suppressLineNumbers/>");
+  }
+  if (paragraph.cnfStyle) {
+    children.push(`<w:cnfStyle w:val="${escapeAttribute2(paragraph.cnfStyle)}"/>`);
+  }
+  if (paragraph.tabStops && paragraph.tabStops.length > 0) {
+    const tabsXml = paragraph.tabStops.map((tab) => {
+      const leaderAttr = tab.leader ? ` w:leader="${tab.leader}"` : "";
+      return `<w:tab w:val="${tab.align}" w:pos="${tab.position}"${leaderAttr}/>`;
+    }).join("");
+    children.push(`<w:tabs>${tabsXml}</w:tabs>`);
+  }
+  if (children.length === 0) return "";
+  return `<w:pPr>${children.join("")}</w:pPr>`;
+}
+function buildTablePropertiesXml(table) {
+  const children = [];
+  if (table.styleId) {
+    children.push(`<w:tblStyle w:val="${escapeAttribute2(table.styleId)}"/>`);
+  }
+  if (table.tblLook) {
+    const attrs = [];
+    if (table.tblLook.val) {
+      attrs.push(`w:val="${escapeAttribute2(table.tblLook.val)}"`);
+    }
+    for (const [key, attr] of [
+      ["firstRow", "w:firstRow"],
+      ["lastRow", "w:lastRow"],
+      ["firstColumn", "w:firstColumn"],
+      ["lastColumn", "w:lastColumn"],
+      ["noHBand", "w:noHBand"],
+      ["noVBand", "w:noVBand"]
+    ]) {
+      const value = table.tblLook[key];
+      if (value !== void 0) {
+        attrs.push(`${attr}="${value ? "1" : "0"}"`);
+      }
+    }
+    if (attrs.length > 0) {
+      children.push(`<w:tblLook ${attrs.join(" ")}/>`);
+    }
+  }
+  return children.length > 0 ? `<w:tblPr>${children.join("")}</w:tblPr>` : "";
+}
+function serializeParagraphBorders(borders) {
+  if (!borders) {
+    return "";
+  }
+  const parts = [];
+  for (const [name, border] of [
+    ["top", borders.top],
+    ["left", borders.left],
+    ["bottom", borders.bottom],
+    ["right", borders.right],
+    ["bar", borders.bar],
+    ["between", borders.between]
+  ]) {
+    const xml = serializeBorder(name, border);
+    if (xml) {
+      parts.push(xml);
+    }
+  }
+  return parts.length > 0 ? `<w:pBdr>${parts.join("")}</w:pBdr>` : "";
+}
+function serializeBorder(name, border) {
+  if (!border) {
+    return "";
+  }
+  const attrs = [];
+  if (border.value) attrs.push(`w:val="${escapeAttribute2(border.value)}"`);
+  if (border.size !== void 0) attrs.push(`w:sz="${border.size}"`);
+  if (border.space !== void 0) attrs.push(`w:space="${border.space}"`);
+  if (border.color) attrs.push(`w:color="${escapeAttribute2(border.color)}"`);
+  return attrs.length > 0 ? `<w:${name} ${attrs.join(" ")}/>` : "";
+}
+function serializeParagraphShading(shading) {
+  if (!shading) {
+    return "";
+  }
+  const attrs = [];
+  if (shading.val) attrs.push(`w:val="${escapeAttribute2(shading.val)}"`);
+  if (shading.color) attrs.push(`w:color="${escapeAttribute2(shading.color)}"`);
+  if (shading.fill) attrs.push(`w:fill="${escapeAttribute2(shading.fill)}"`);
+  return attrs.length > 0 ? `<w:shd ${attrs.join(" ")}/>` : "";
+}
+function serializeRunPropertiesFromMarks(marks) {
+  return serializeRunProperties(marks);
+}
+function serializeParagraph(paragraph, state, cursor, paragraphIndex) {
+  let xml = "<w:p>";
+  const boundaries = /* @__PURE__ */ new Map();
+  const paragraphStart = 0;
+  const paragraphStartTagEnd = xml.length;
+  boundaries.set(cursor, paragraphStartTagEnd);
+  let paragraphPropertiesStart;
+  let paragraphPropertiesEnd;
+  const paragraphPropertiesXml = buildParagraphPropertiesXml(paragraph);
+  if (paragraphPropertiesXml.length > 0) {
+    paragraphPropertiesStart = xml.length;
+    xml += paragraphPropertiesXml;
+    paragraphPropertiesEnd = xml.length;
+  }
+  const children = serializeParagraphChildren(paragraph.children, state, cursor, xml.length);
+  xml += children.xml;
+  const contentEmpty = children.xml.length === 0;
+  if (contentEmpty) {
+    xml += "<w:r><w:t></w:t></w:r>";
+  }
+  const paragraphEndTagStart = xml.length;
+  xml += "</w:p>";
+  if (!children.boundaries.has(children.cursor)) {
+    children.boundaries.set(children.cursor, paragraphEndTagStart);
+  }
+  return {
+    xml,
+    nextCursor: children.cursor,
+    boundary: {
+      paragraphIndex,
+      start: cursor,
+      end: children.cursor,
+      boundaries: children.boundaries,
+      paragraphStart,
+      paragraphStartTagEnd,
+      paragraphEndTagStart,
+      paragraphEnd: xml.length,
+      ...paragraphPropertiesStart !== void 0 ? { paragraphPropertiesStart } : {},
+      ...paragraphPropertiesEnd !== void 0 ? { paragraphPropertiesEnd } : {}
+    }
+  };
+}
+function serializeParagraphChildren(children, state, cursor, xmlOffset) {
+  const pieces = [];
+  const boundaries = /* @__PURE__ */ new Map();
+  let nextCursor = cursor;
+  let nextOffset = xmlOffset;
+  boundaries.set(nextCursor, nextOffset);
+  for (const child of children) {
+    const result = serializeInlineNode(child, state, nextCursor, nextOffset);
+    pieces.push(result.xml);
+    for (const [position, index] of result.boundaries) {
+      boundaries.set(position, index);
+    }
+    nextCursor = result.cursor;
+    nextOffset += result.xml.length;
+  }
+  return {
+    xml: pieces.join(""),
+    cursor: nextCursor,
+    boundaries
+  };
+}
+function serializeRunPiece(piece) {
+  switch (piece.kind) {
+    case "text":
+      return serializeText(piece.text);
+    case "tab":
+      return "<w:tab/>";
+    case "hard_break":
+      return "<w:br/>";
+  }
+}
+function serializeText(text) {
+  const preserve = requiresPreservedSpace(text) ? ` xml:space="preserve"` : "";
+  return `<w:t${preserve}>${escapeXml2(text)}</w:t>`;
+}
+function serializeInlineNode(node, state, cursor, xmlOffset) {
+  switch (node.type) {
+    case "text": {
+      const xml = serializeRun({
+        kind: "text",
+        text: node.text,
+        ...node.marks && node.marks.length > 0 ? { marks: node.marks } : {}
+      });
+      const boundaries = /* @__PURE__ */ new Map();
+      boundaries.set(cursor, xmlOffset);
+      boundaries.set(cursor + Array.from(node.text).length, xmlOffset + xml.length);
+      return {
+        xml,
+        cursor: cursor + Array.from(node.text).length,
+        boundaries
+      };
+    }
+    case "tab": {
+      const xml = serializeRun({ kind: "tab" });
+      const boundaries = /* @__PURE__ */ new Map();
+      boundaries.set(cursor, xmlOffset);
+      boundaries.set(cursor + 1, xmlOffset + xml.length);
+      return {
+        xml,
+        cursor: cursor + 1,
+        boundaries
+      };
+    }
+    case "column_break": {
+      const xml = `<w:r><w:br w:type="column"/></w:r>`;
+      const boundaries = /* @__PURE__ */ new Map();
+      boundaries.set(cursor, xmlOffset);
+      boundaries.set(cursor + 1, xmlOffset + xml.length);
+      return {
+        xml,
+        cursor: cursor + 1,
+        boundaries
+      };
+    }
+    case "hard_break": {
+      const xml = serializeRun({ kind: "hard_break" });
+      const boundaries = /* @__PURE__ */ new Map();
+      boundaries.set(cursor, xmlOffset);
+      boundaries.set(cursor + 1, xmlOffset + xml.length);
+      return {
+        xml,
+        cursor: cursor + 1,
+        boundaries
+      };
+    }
+    case "symbol": {
+      const xml = serializeTableInlineNode(node, state);
+      const boundaries = /* @__PURE__ */ new Map();
+      boundaries.set(cursor, xmlOffset);
+      boundaries.set(cursor + 1, xmlOffset + xml.length);
+      return {
+        xml,
+        cursor: cursor + 1,
+        boundaries
+      };
+    }
+    case "image": {
+      const xml = serializeImageNode(node, state);
+      const boundaries = /* @__PURE__ */ new Map();
+      boundaries.set(cursor, xmlOffset);
+      boundaries.set(cursor + 1, xmlOffset + xml.length);
+      return {
+        xml,
+        cursor: cursor + 1,
+        boundaries
+      };
+    }
+    case "opaque_inline": {
+      const xml = lookupOpaqueXml(node.fragmentId, state);
+      const boundaries = /* @__PURE__ */ new Map();
+      boundaries.set(cursor, xmlOffset);
+      boundaries.set(cursor + 1, xmlOffset + xml.length);
+      return {
+        xml,
+        cursor: cursor + 1,
+        boundaries
+      };
+    }
+    case "chart_preview":
+    case "smartart_preview":
+    case "shape":
+    case "wordart":
+    case "vml_shape": {
+      const xml = wrapInlineRawXml(node.rawXml);
+      const boundaries = /* @__PURE__ */ new Map();
+      boundaries.set(cursor, xmlOffset);
+      boundaries.set(cursor + 1, xmlOffset + xml.length);
+      return {
+        xml,
+        cursor: cursor + 1,
+        boundaries
+      };
+    }
+    case "hyperlink": {
+      const hyperlinkOpen = node.href.startsWith("#") ? `<w:hyperlink w:anchor="${escapeAttribute2(node.href.slice(1))}">` : (() => {
+        const relationshipId = `rIdHyperlink${state.nextHyperlinkRelationshipIndex}`;
+        state.nextHyperlinkRelationshipIndex += 1;
+        state.relationships.push({
+          id: relationshipId,
+          type: HYPERLINK_RELATIONSHIP_TYPE,
+          target: node.href,
+          targetMode: "external"
+        });
+        state.retainedRelationshipIds.add(relationshipId);
+        return `<w:hyperlink r:id="${relationshipId}">`;
+      })();
+      const hyperlinkClose = "</w:hyperlink>";
+      const boundaries = /* @__PURE__ */ new Map();
+      let nextCursor = cursor;
+      let nextOffset = xmlOffset + hyperlinkOpen.length;
+      boundaries.set(cursor, nextOffset);
+      const children = [];
+      for (const child of node.children) {
+        const result = serializeInlineNode(child, state, nextCursor, nextOffset);
+        children.push(result.xml);
+        for (const [position, index] of result.boundaries) {
+          boundaries.set(position, index);
+        }
+        nextCursor = result.cursor;
+        nextOffset += result.xml.length;
+      }
+      boundaries.set(nextCursor, nextOffset);
+      return {
+        xml: `${hyperlinkOpen}${children.join("")}${hyperlinkClose}`,
+        cursor: nextCursor,
+        boundaries
+      };
+    }
+    case "field": {
+      if (node.children && node.children.length > 0) {
+        const boundaries2 = /* @__PURE__ */ new Map();
+        boundaries2.set(cursor, xmlOffset);
+        let nextCursor = cursor;
+        let nextOffset = xmlOffset;
+        if (node.fieldType === "complex") {
+          const beginXml = `<w:r><w:fldChar w:fldCharType="begin"/></w:r><w:r><w:instrText xml:space="preserve"> ${escapeXml2(node.instruction)} </w:instrText></w:r><w:r><w:fldChar w:fldCharType="separate"/></w:r>`;
+          nextOffset += beginXml.length;
+          const children2 = [beginXml];
+          for (const child of node.children) {
+            const result = serializeInlineNode(child, state, nextCursor, nextOffset);
+            children2.push(result.xml);
+            for (const [position, index] of result.boundaries) {
+              boundaries2.set(position, index);
+            }
+            nextCursor = result.cursor;
+            nextOffset += result.xml.length;
+          }
+          const endXml = `<w:r><w:fldChar w:fldCharType="end"/></w:r>`;
+          children2.push(endXml);
+          nextOffset += endXml.length;
+          boundaries2.set(nextCursor, nextOffset);
+          return { xml: children2.join(""), cursor: nextCursor, boundaries: boundaries2 };
+        }
+        const openXml = `<w:fldSimple w:instr="${escapeAttribute2(node.instruction)}">`;
+        nextOffset += openXml.length;
+        const children = [openXml];
+        for (const child of node.children) {
+          const result = serializeInlineNode(child, state, nextCursor, nextOffset);
+          children.push(result.xml);
+          for (const [position, index] of result.boundaries) {
+            boundaries2.set(position, index);
+          }
+          nextCursor = result.cursor;
+          nextOffset += result.xml.length;
+        }
+        children.push("</w:fldSimple>");
+        nextOffset += "</w:fldSimple>".length;
+        boundaries2.set(nextCursor, nextOffset);
+        return { xml: children.join(""), cursor: nextCursor, boundaries: boundaries2 };
+      }
+      const xml = `<w:fldSimple w:instr="${escapeAttribute2(node.instruction)}"/>`;
+      const boundaries = /* @__PURE__ */ new Map();
+      boundaries.set(cursor, xmlOffset);
+      boundaries.set(cursor + 1, xmlOffset + xml.length);
+      return {
+        xml,
+        cursor: cursor + 1,
+        boundaries
+      };
+    }
+    case "bookmark_start": {
+      const xml = `<w:bookmarkStart w:id="${escapeAttribute2(node.bookmarkId)}" w:name="${escapeAttribute2(node.name)}"/>`;
+      const boundaries = /* @__PURE__ */ new Map();
+      boundaries.set(cursor, xmlOffset);
+      boundaries.set(cursor, xmlOffset + xml.length);
+      return { xml, cursor, boundaries };
+    }
+    case "bookmark_end": {
+      const xml = `<w:bookmarkEnd w:id="${escapeAttribute2(node.bookmarkId)}"/>`;
+      const boundaries = /* @__PURE__ */ new Map();
+      boundaries.set(cursor, xmlOffset);
+      boundaries.set(cursor, xmlOffset + xml.length);
+      return { xml, cursor, boundaries };
+    }
+    case "footnote_ref": {
+      const refElement = node.noteKind === "footnote" ? `<w:footnoteReference w:id="${escapeAttribute2(node.noteId)}"/>` : `<w:endnoteReference w:id="${escapeAttribute2(node.noteId)}"/>`;
+      const styleVal = node.noteKind === "footnote" ? "FootnoteReference" : "EndnoteReference";
+      const xml = `<w:r><w:rPr><w:rStyle w:val="${styleVal}"/></w:rPr>${refElement}</w:r>`;
+      const boundaries = /* @__PURE__ */ new Map();
+      boundaries.set(cursor, xmlOffset);
+      boundaries.set(cursor + 1, xmlOffset + xml.length);
+      return {
+        xml,
+        cursor: cursor + 1,
+        boundaries
+      };
+    }
+    default: {
+      const boundaries = /* @__PURE__ */ new Map();
+      boundaries.set(cursor, xmlOffset);
+      return { xml: "", cursor, boundaries };
+    }
+  }
+}
+function serializeImageNode(node, state) {
+  const placementXml = typeof node.placementXml === "string" ? node.placementXml.trim() : "";
+  if (placementXml.length > 0) {
+    return placementXml.startsWith("<w:r") ? placementXml : `<w:r>${placementXml}</w:r>`;
+  }
+  const mediaItem = state.media.items[node.mediaId];
+  if (mediaItem?.relationshipId && state.existingRelationshipMap.has(mediaItem.relationshipId)) {
+    const altText = node.altText ?? mediaItem.altText ?? mediaItem.filename;
+    return `<w:r><w:drawing><wp:inline xmlns:a="http://schemas.openxmlformats.org/drawingml/2006/main" xmlns:pic="http://schemas.openxmlformats.org/drawingml/2006/picture" xmlns:wp="http://schemas.openxmlformats.org/drawingml/2006/wordprocessingDrawing"><wp:extent cx="9525" cy="9525"/><wp:docPr id="1" name="${escapeAttribute2(mediaItem.filename)}" descr="${escapeAttribute2(altText ?? "")}"/><wp:cNvGraphicFramePr/><a:graphic><a:graphicData uri="http://schemas.openxmlformats.org/drawingml/2006/picture"><pic:pic><pic:nvPicPr><pic:cNvPr id="0" name="${escapeAttribute2(mediaItem.filename)}"/><pic:cNvPicPr/></pic:nvPicPr><pic:blipFill><a:blip r:embed="${escapeAttribute2(mediaItem.relationshipId)}"/><a:stretch><a:fillRect/></a:stretch></pic:blipFill><pic:spPr><a:xfrm><a:off x="0" y="0"/><a:ext cx="9525" cy="9525"/></a:xfrm><a:prstGeom prst="rect"><a:avLst/></a:prstGeom></pic:spPr></pic:pic></a:graphicData></a:graphic></wp:inline></w:drawing></w:r>`;
+  }
+  return serializeRun({
+    kind: "text",
+    text: node.altText ?? "[Image]"
+  });
+}
+function serializeRun(piece) {
+  const marks = piece.kind === "text" ? piece.marks : void 0;
+  const properties = serializeRunProperties(marks);
+  const content = serializeRunPiece(piece);
+  return `<w:r>${properties}${content}</w:r>`;
+}
+function serializeRunProperties(marks) {
+  if (!marks || marks.length === 0) {
+    return "";
+  }
+  const markParts = [];
+  for (const mark of marks) {
+    switch (mark.type) {
+      case "bold":
+        markParts.push("<w:b/>");
+        break;
+      case "italic":
+        markParts.push("<w:i/>");
+        break;
+      case "underline":
+        markParts.push(`<w:u w:val="single"/>`);
+        break;
+      case "strikethrough":
+        markParts.push("<w:strike/>");
+        break;
+      case "doubleStrikethrough":
+        markParts.push("<w:dstrike/>");
+        break;
+      case "vanish":
+        markParts.push("<w:vanish/>");
+        break;
+      case "lang":
+        markParts.push(`<w:lang w:val="${escapeAttribute2(mark.val)}"/>`);
+        break;
+      case "highlight":
+        markParts.push(`<w:highlight w:val="${escapeAttribute2(mark.val)}"/>`);
+        break;
+      case "backgroundColor":
+        markParts.push(
+          `<w:shd w:val="clear" w:color="auto" w:fill="${escapeAttribute2(mark.color)}"/>`
+        );
+        break;
+      case "charSpacing":
+        markParts.push(`<w:spacing w:val="${mark.val}"/>`);
+        break;
+      case "kerning":
+        markParts.push(`<w:kern w:val="${mark.val}"/>`);
+        break;
+      case "emboss":
+        markParts.push("<w:emboss/>");
+        break;
+      case "imprint":
+        markParts.push("<w:imprint/>");
+        break;
+      case "shadow":
+        markParts.push("<w:shadow/>");
+        break;
+      case "position":
+        markParts.push(`<w:position w:val="${mark.val}"/>`);
+        break;
+      case "textFill":
+        markParts.push(mark.xml);
+        break;
+      case "fontFamily":
+        markParts.push(`<w:rFonts w:ascii="${escapeAttribute2(mark.val)}" w:hAnsi="${escapeAttribute2(mark.val)}"/>`);
+        break;
+      case "fontSize":
+        markParts.push(`<w:sz w:val="${mark.val}"/>`);
+        break;
+      case "textColor":
+        markParts.push(`<w:color w:val="${escapeAttribute2(mark.color)}"/>`);
+        break;
+      case "smallCaps":
+        markParts.push("<w:smallCaps/>");
+        break;
+      case "allCaps":
+        markParts.push("<w:caps/>");
+        break;
+    }
+  }
+  const children = markParts.join("");
+  return children.length > 0 ? `<w:rPr>${children}</w:rPr>` : "";
+}
+function requiresPreservedSpace(text) {
+  return /^\s/.test(text) || /\s$/.test(text) || text.includes("  ");
+}
+function lookupOpaqueXml(fragmentId, state) {
+  const fragment = getOpaqueFragment(state.preservation, fragmentId);
+  if (!fragment || fragment.payloadKind !== "xml-subtree") {
+    throw new Error(`Missing preserved OOXML fragment ${fragmentId} during serialization.`);
+  }
+  retainRelationshipsForFragment(
+    fragment,
+    state.relationships,
+    state.existingRelationshipMap,
+    state.retainedRelationshipIds
+  );
+  return fragment.payloadReference;
+}
+function cloneRelationship3(relationship) {
+  return { ...relationship };
+}
+function looksLikeSectionPropertiesXml(xml) {
+  return /^<[^>]*:?sectPr(?:\s|>|\/)/.test(xml.trim());
+}
+function escapeXml2(value) {
+  return value.replace(/&/g, "&amp;").replace(/</g, "&lt;").replace(/>/g, "&gt;");
+}
+function escapeAttribute2(value) {
+  return escapeXml2(value).replace(/"/g, "&quot;");
+}
+function offsetParagraphBoundary(boundary, offset) {
+  return {
+    ...boundary,
+    boundaries: new Map(
+      [...boundary.boundaries.entries()].map(([position, index]) => [
+        position,
+        index + offset
+      ])
+    ),
+    paragraphStart: boundary.paragraphStart + offset,
+    paragraphStartTagEnd: boundary.paragraphStartTagEnd + offset,
+    paragraphEndTagStart: boundary.paragraphEndTagStart + offset,
+    paragraphEnd: boundary.paragraphEnd + offset,
+    ...boundary.paragraphPropertiesStart !== void 0 ? { paragraphPropertiesStart: boundary.paragraphPropertiesStart + offset } : {},
+    ...boundary.paragraphPropertiesEnd !== void 0 ? { paragraphPropertiesEnd: boundary.paragraphPropertiesEnd + offset } : {},
+    ...boundary.paragraphRunPropertiesStart !== void 0 ? { paragraphRunPropertiesStart: boundary.paragraphRunPropertiesStart + offset } : {},
+    ...boundary.paragraphRunPropertiesEnd !== void 0 ? { paragraphRunPropertiesEnd: boundary.paragraphRunPropertiesEnd + offset } : {}
+  };
+}
+function serializeDocumentAttributes(attributes, content) {
+  const merged = {
+    "xmlns:r": "http://schemas.openxmlformats.org/officeDocument/2006/relationships",
+    "xmlns:w": "http://schemas.openxmlformats.org/wordprocessingml/2006/main",
+    ...content && documentNeedsW14Namespace(content) ? { "xmlns:w14": "http://schemas.microsoft.com/office/word/2010/wordml" } : {},
+    ...attributes ?? {}
+  };
+  return Object.entries(merged).map(([name, value]) => ` ${name}="${escapeAttribute2(value)}"`).join("");
+}
+function serializeSectionPropertiesXml(props) {
+  const children = [];
+  if (props.headerReferences) {
+    for (const ref of props.headerReferences) {
+      children.push(`<w:headerReference w:type="${escapeAttribute2(ref.variant)}" r:id="${escapeAttribute2(ref.relationshipId)}"/>`);
+    }
+  }
+  if (props.footerReferences) {
+    for (const ref of props.footerReferences) {
+      children.push(`<w:footerReference w:type="${escapeAttribute2(ref.variant)}" r:id="${escapeAttribute2(ref.relationshipId)}"/>`);
+    }
+  }
+  if (props.sectionType) {
+    children.push(`<w:type w:val="${escapeAttribute2(props.sectionType)}"/>`);
+  }
+  if (props.pageSize) {
+    let pgSz = `<w:pgSz w:w="${props.pageSize.width}" w:h="${props.pageSize.height}"`;
+    if (props.pageSize.orientation) {
+      pgSz += ` w:orient="${props.pageSize.orientation}"`;
+    }
+    pgSz += "/>";
+    children.push(pgSz);
+  }
+  if (props.pageMargins) {
+    let pgMar = `<w:pgMar w:top="${props.pageMargins.top}" w:right="${props.pageMargins.right}" w:bottom="${props.pageMargins.bottom}" w:left="${props.pageMargins.left}"`;
+    if (props.pageMargins.header !== void 0) pgMar += ` w:header="${props.pageMargins.header}"`;
+    if (props.pageMargins.footer !== void 0) pgMar += ` w:footer="${props.pageMargins.footer}"`;
+    if (props.pageMargins.gutter !== void 0) pgMar += ` w:gutter="${props.pageMargins.gutter}"`;
+    pgMar += "/>";
+    children.push(pgMar);
+  }
+  if (props.columns) {
+    let cols = "<w:cols";
+    if (props.columns.count !== void 0) cols += ` w:num="${props.columns.count}"`;
+    if (props.columns.space !== void 0) cols += ` w:space="${props.columns.space}"`;
+    if (props.columns.equalWidth !== void 0) cols += ` w:equalWidth="${props.columns.equalWidth ? "1" : "0"}"`;
+    if (props.columns.separator) cols += ` w:sep="1"`;
+    if (props.columns.columns && props.columns.columns.length > 0) {
+      cols += ">";
+      for (const col of props.columns.columns) {
+        let colXml = `<w:col w:w="${col.width}"`;
+        if (col.space !== void 0) colXml += ` w:space="${col.space}"`;
+        colXml += "/>";
+        cols += colXml;
+      }
+      cols += "</w:cols>";
+    } else {
+      cols += "/>";
+    }
+    children.push(cols);
+  }
+  if (props.pageNumbering) {
+    let pgNum = "<w:pgNumType";
+    if (props.pageNumbering.format) pgNum += ` w:fmt="${escapeAttribute2(props.pageNumbering.format)}"`;
+    if (props.pageNumbering.start !== void 0) pgNum += ` w:start="${props.pageNumbering.start}"`;
+    if (props.pageNumbering.chapStyle) pgNum += ` w:chapStyle="${escapeAttribute2(props.pageNumbering.chapStyle)}"`;
+    if (props.pageNumbering.chapSep) pgNum += ` w:chapSep="${escapeAttribute2(props.pageNumbering.chapSep)}"`;
+    pgNum += "/>";
+    children.push(pgNum);
+  }
+  if (props.lineNumbering) {
+    let lineNumbering = "<w:lnNumType";
+    if (props.lineNumbering.countBy !== void 0) {
+      lineNumbering += ` w:countBy="${props.lineNumbering.countBy}"`;
+    }
+    if (props.lineNumbering.start !== void 0) {
+      lineNumbering += ` w:start="${props.lineNumbering.start}"`;
+    }
+    if (props.lineNumbering.distance !== void 0) {
+      lineNumbering += ` w:distance="${props.lineNumbering.distance}"`;
+    }
+    if (props.lineNumbering.restart) {
+      lineNumbering += ` w:restart="${escapeAttribute2(props.lineNumbering.restart)}"`;
+    }
+    lineNumbering += "/>";
+    children.push(lineNumbering);
+  }
+  if (props.pageBorders) {
+    const attrs = [];
+    if (props.pageBorders.offsetFrom) {
+      attrs.push(`w:offsetFrom="${escapeAttribute2(props.pageBorders.offsetFrom)}"`);
+    }
+    if (props.pageBorders.display) {
+      attrs.push(`w:display="${escapeAttribute2(props.pageBorders.display)}"`);
+    }
+    if (props.pageBorders.zOrder) {
+      attrs.push(`w:zOrder="${escapeAttribute2(props.pageBorders.zOrder)}"`);
+    }
+    const borderXml = [
+      serializeBorder("top", props.pageBorders.top),
+      serializeBorder("left", props.pageBorders.left),
+      serializeBorder("bottom", props.pageBorders.bottom),
+      serializeBorder("right", props.pageBorders.right)
+    ].filter((entry) => entry.length > 0);
+    if (attrs.length > 0 || borderXml.length > 0) {
+      children.push(
+        `<w:pgBorders${attrs.length > 0 ? ` ${attrs.join(" ")}` : ""}>${borderXml.join("")}</w:pgBorders>`
+      );
+    }
+  }
+  if (props.titlePage) {
+    children.push("<w:titlePg/>");
+  }
+  if (props.documentGrid) {
+    const attrs = [];
+    if (props.documentGrid.type) {
+      attrs.push(`w:type="${escapeAttribute2(props.documentGrid.type)}"`);
+    }
+    if (props.documentGrid.linePitch !== void 0) {
+      attrs.push(`w:linePitch="${props.documentGrid.linePitch}"`);
+    }
+    if (props.documentGrid.charSpace !== void 0) {
+      attrs.push(`w:charSpace="${props.documentGrid.charSpace}"`);
+    }
+    if (attrs.length > 0) {
+      children.push(`<w:docGrid ${attrs.join(" ")}/>`);
+    }
+  }
+  if (children.length === 0) {
+    return "<w:sectPr/>";
+  }
+  return `<w:sectPr>${children.join("")}</w:sectPr>`;
+}
+function wrapInlineRawXml(rawXml) {
+  const trimmed = rawXml.trimStart();
+  return trimmed.startsWith("<w:r") ? rawXml : `<w:r>${rawXml}</w:r>`;
+}
+function documentNeedsW14Namespace(content) {
+  const blockQueue = [...content.children];
+  while (blockQueue.length > 0) {
+    const block = blockQueue.shift();
+    if (!block) {
+      continue;
+    }
+    if (block.type === "paragraph") {
+      for (const child of block.children) {
+        if ((child.type === "text" || child.type === "symbol") && child.marks?.some((mark) => mark.type === "textFill")) {
+          return true;
+        }
+      }
+      continue;
+    }
+    if (block.type === "table") {
+      for (const row of block.rows) {
+        for (const cell of row.cells) {
+          blockQueue.push(...cell.children);
+        }
+      }
+    }
+  }
+  return false;
+}
+
+// src/io/export/serialize-comments.ts
+var DEFAULT_COMMENTS_ROOT_TAG = `<w:comments xmlns:w="http://schemas.openxmlformats.org/wordprocessingml/2006/main" xmlns:w14="http://schemas.microsoft.com/office/word/2010/wordml" xmlns:mc="http://schemas.openxmlformats.org/markup-compatibility/2006" mc:Ignorable="w14">`;
+var DEFAULT_COMMENTS_EXTENDED_ROOT_TAG = `<w15:commentsEx xmlns:w15="http://schemas.microsoft.com/office/word/2012/wordml">`;
+var DEFAULT_COMMENTS_IDS_ROOT_TAG = `<w16cid:commentsIds xmlns:w16cid="http://schemas.microsoft.com/office/word/2016/wordml/cid">`;
+var DEFAULT_PEOPLE_ROOT_TAG = `<w15:people xmlns:w15="http://schemas.microsoft.com/office/word/2012/wordml">`;
+function serializeMergedCommentsXml(threads, options = {}) {
+  const serializableThreads = threads.filter((thread) => thread.entries.length > 0);
+  const preservedDefinitions = (options.preservedDefinitions ?? []).slice().sort((left, right) => left.order - right.order);
+  const runtimeThreadById = new Map(
+    serializableThreads.map((thread) => [thread.commentId, thread])
+  );
+  const exportCommentIds = options.exportCommentIds ?? createCommentExportIdMap(serializableThreads, preservedDefinitions);
+  const serializableEntries = createSerializableEntries(
+    serializableThreads,
+    preservedDefinitions,
+    exportCommentIds
+  );
+  const serializedEntryByOoxmlId = new Map(
+    serializableEntries.map((entry) => [entry.exportCommentId, entry])
+  );
+  const emittedThreadIds = /* @__PURE__ */ new Set();
+  const mergedComments = [];
+  for (const definition of preservedDefinitions) {
+    const ownedThread = runtimeThreadById.get(definition.commentId);
+    if (ownedThread) {
+      if (emittedThreadIds.has(ownedThread.commentId)) {
+        continue;
+      }
+      mergedComments.push(
+        ...serializeThreadEntries(
+          serializableEntries.filter((entry) => entry.thread.commentId === ownedThread.commentId)
+        )
+      );
+      emittedThreadIds.add(ownedThread.commentId);
+      continue;
+    }
+    if (serializedEntryByOoxmlId.has(definition.commentId)) {
+      continue;
+    }
+    mergedComments.push(definition.rawXml);
+  }
+  for (const thread of serializableThreads) {
+    if (emittedThreadIds.has(thread.commentId)) {
+      continue;
+    }
+    mergedComments.push(
+      ...serializeThreadEntries(
+        serializableEntries.filter((entry) => entry.thread.commentId === thread.commentId)
+      )
+    );
+    emittedThreadIds.add(thread.commentId);
+  }
+  const mergedExtendedEntries = [
+    ...serializePreservedCommentExtensions(
+      preservedDefinitions.filter((definition) => !serializedEntryByOoxmlId.has(definition.commentId))
+    ),
+    ...serializableEntries.map((entry) => serializeCommentExtension(entry)).filter((xml) => Boolean(xml))
+  ];
+  const mergedDurableIds = [
+    ...serializePreservedCommentIds(
+      preservedDefinitions.filter((definition) => !serializedEntryByOoxmlId.has(definition.commentId))
+    ),
+    ...serializableEntries.map((entry) => serializeCommentDurableId(entry)).filter((xml) => Boolean(xml))
+  ];
+  const peopleAuthors = /* @__PURE__ */ new Set([
+    ...options.peopleAuthors ?? [],
+    ...preservedDefinitions.map((definition) => definition.authorId).filter((authorId) => typeof authorId === "string" && authorId.length > 0),
+    ...serializableEntries.map((entry) => entry.entry.authorId).filter((authorId) => typeof authorId === "string" && authorId.length > 0)
+  ]);
+  return {
+    commentsXml: [
+      `<?xml version="1.0" encoding="UTF-8" standalone="yes"?>`,
+      normalizeCommentsRootTag(options.sourceRootTag ?? DEFAULT_COMMENTS_ROOT_TAG),
+      ...mergedComments,
+      `</w:comments>`
+    ].join("\n"),
+    serializedCommentIds: serializableThreads.map((thread) => thread.commentId),
+    commentsExtendedXml: mergedExtendedEntries.length > 0 ? [
+      `<?xml version="1.0" encoding="UTF-8" standalone="yes"?>`,
+      options.sourceExtendedRootTag ?? DEFAULT_COMMENTS_EXTENDED_ROOT_TAG,
+      ...mergedExtendedEntries,
+      `</w15:commentsEx>`
+    ].join("\n") : void 0,
+    commentsIdsXml: mergedDurableIds.length > 0 ? [
+      `<?xml version="1.0" encoding="UTF-8" standalone="yes"?>`,
+      options.sourceIdsRootTag ?? DEFAULT_COMMENTS_IDS_ROOT_TAG,
+      ...mergedDurableIds,
+      `</w16cid:commentsIds>`
+    ].join("\n") : void 0,
+    peopleXml: peopleAuthors.size > 0 ? [
+      `<?xml version="1.0" encoding="UTF-8" standalone="yes"?>`,
+      options.sourcePeopleRootTag ?? DEFAULT_PEOPLE_ROOT_TAG,
+      ...[...peopleAuthors].sort((left, right) => left.localeCompare(right)).map(
+        (authorId) => `<w15:person w15:author="${escapeAttribute3(authorId)}" />`
+      ),
+      `</w15:people>`
+    ].join("\n") : void 0
+  };
+}
+function normalizeCommentsRootTag(rootTag) {
+  let normalized = rootTag;
+  if (!/\bxmlns:w14=/u.test(normalized)) {
+    normalized = normalized.replace(
+      />$/u,
+      ` xmlns:w14="http://schemas.microsoft.com/office/word/2010/wordml">`
+    );
+  }
+  if (!/\bxmlns:mc=/u.test(normalized)) {
+    normalized = normalized.replace(
+      />$/u,
+      ` xmlns:mc="http://schemas.openxmlformats.org/markup-compatibility/2006">`
+    );
+  }
+  if (!/\bmc:Ignorable=/u.test(normalized)) {
+    normalized = normalized.replace(/>$/u, ` mc:Ignorable="w14">`);
+  } else if (!/\bmc:Ignorable="[^"]*\bw14\b/u.test(normalized)) {
+    normalized = normalized.replace(
+      /\bmc:Ignorable="([^"]*)"/u,
+      (_match, value) => `mc:Ignorable="${`${value} w14`.trim().replace(/\s+/gu, " ")}"`
+    );
+  }
+  return normalized;
+}
+function serializeCommentAnchorsIntoDocumentXml(documentXml, threads, paragraphs = mapParagraphBoundaries(documentXml), options = {}) {
+  const insertions = /* @__PURE__ */ new Map();
+  const serializedCommentIds = [];
+  const skippedCommentIds = [];
+  const exportCommentIds = options.exportCommentIds ?? createCommentExportIdMap(threads);
+  for (const thread of threads) {
+    const { anchor } = thread;
+    if (anchor.kind !== "range") {
+      skippedCommentIds.push(thread.commentId);
+      continue;
+    }
+    const paragraph = paragraphs.find(
+      (candidate) => anchor.range.from >= candidate.start && anchor.range.to <= candidate.end
+    );
+    if (!paragraph) {
+      skippedCommentIds.push(thread.commentId);
+      continue;
+    }
+    const startIndex = paragraph.boundaries.get(anchor.range.from);
+    const endIndex = paragraph.boundaries.get(anchor.range.to);
+    if (startIndex === void 0 || endIndex === void 0) {
+      skippedCommentIds.push(thread.commentId);
+      continue;
+    }
+    const exportCommentId = exportCommentIds.get(thread.commentId) ?? thread.commentId;
+    pushInsertion(
+      insertions,
+      startIndex,
+      `<w:commentRangeStart w:id="${escapeAttribute3(exportCommentId)}"/>`
+    );
+    pushInsertion(
+      insertions,
+      endIndex,
+      `<w:commentRangeEnd w:id="${escapeAttribute3(exportCommentId)}"/>`
+    );
+    pushInsertion(
+      insertions,
+      endIndex,
+      `<w:r><w:commentReference w:id="${escapeAttribute3(exportCommentId)}"/></w:r>`
+    );
+    serializedCommentIds.push(thread.commentId);
+  }
+  const sortedInsertions = [...insertions.entries()].sort((left, right) => left[0] - right[0]);
+  let cursor = 0;
+  let output = "";
+  for (const [index, snippets] of sortedInsertions) {
+    output += documentXml.slice(cursor, index);
+    output += snippets.join("");
+    cursor = index;
+  }
+  output += documentXml.slice(cursor);
+  return {
+    documentXml: output,
+    serializedCommentIds,
+    skippedCommentIds
+  };
+}
+function createCommentExportIdMap(threads, preservedDefinitions = []) {
+  const exportIds = /* @__PURE__ */ new Map();
+  const reservedNumericIds = /* @__PURE__ */ new Set();
+  for (const definition of preservedDefinitions) {
+    const numericId = parseOoxmlNumericId(definition.commentId);
+    if (numericId !== void 0) {
+      reservedNumericIds.add(numericId);
+    }
+  }
+  for (const thread of threads) {
+    const rootEntry = getRootEntry(thread);
+    const preferredValue = thread.metadata?.rootOoxmlCommentId ?? rootEntry?.metadata?.ooxmlCommentId ?? thread.commentId;
+    const numericId = parseOoxmlNumericId(preferredValue);
+    if (numericId !== void 0 && !reservedNumericIds.has(numericId)) {
+      exportIds.set(thread.commentId, String(numericId));
+      reservedNumericIds.add(numericId);
+    }
+  }
+  let nextGeneratedId = reservedNumericIds.size > 0 ? Math.max(...reservedNumericIds) + 1 : 1;
+  for (const thread of threads) {
+    if (exportIds.has(thread.commentId)) {
+      continue;
+    }
+    while (reservedNumericIds.has(nextGeneratedId)) {
+      nextGeneratedId += 1;
+    }
+    exportIds.set(thread.commentId, String(nextGeneratedId));
+    reservedNumericIds.add(nextGeneratedId);
+    nextGeneratedId += 1;
+  }
+  return exportIds;
+}
+function createSerializableEntries(threads, preservedDefinitions, exportCommentIds) {
+  const entries = [];
+  const reservedNumericIds = /* @__PURE__ */ new Set();
+  for (const definition of preservedDefinitions) {
+    const numericId = parseOoxmlNumericId(definition.commentId);
+    if (numericId !== void 0) {
+      reservedNumericIds.add(numericId);
+    }
+  }
+  for (const thread of threads) {
+    const rootEntry = getRootEntry(thread);
+    if (!rootEntry) {
+      continue;
+    }
+    const rootExportCommentId = exportCommentIds.get(thread.commentId) ?? thread.commentId;
+    const rootNumericId = parseOoxmlNumericId(rootExportCommentId);
+    if (rootNumericId !== void 0) {
+      reservedNumericIds.add(rootNumericId);
+    }
+    const rootParaId = rootEntry.metadata?.paraId ?? thread.metadata?.rootParaId ?? generateParaId(thread.commentId, 0);
+    const rootDurableId = rootEntry.metadata?.durableId ?? createDurableId(rootEntry, rootExportCommentId, 0);
+    entries.push({
+      thread,
+      entry: rootEntry,
+      exportCommentId: rootExportCommentId,
+      paraId: rootParaId,
+      durableId: rootDurableId,
+      isRoot: true
+    });
+    for (let index = 1; index < thread.entries.length; index += 1) {
+      const entry = thread.entries[index];
+      if (!entry) {
+        continue;
+      }
+      const preferredCommentId = entry.metadata?.ooxmlCommentId;
+      let exportCommentId;
+      const preferredNumericId = preferredCommentId ? parseOoxmlNumericId(preferredCommentId) : void 0;
+      if (preferredNumericId !== void 0 && !reservedNumericIds.has(preferredNumericId)) {
+        exportCommentId = String(preferredNumericId);
+        reservedNumericIds.add(preferredNumericId);
+      } else {
+        let nextGeneratedId = reservedNumericIds.size > 0 ? Math.max(...reservedNumericIds) + 1 : 1;
+        while (reservedNumericIds.has(nextGeneratedId)) {
+          nextGeneratedId += 1;
+        }
+        exportCommentId = String(nextGeneratedId);
+        reservedNumericIds.add(nextGeneratedId);
+      }
+      entries.push({
+        thread,
+        entry,
+        exportCommentId,
+        paraId: entry.metadata?.paraId ?? generateParaId(thread.commentId, index),
+        durableId: entry.metadata?.durableId ?? createDurableId(entry, exportCommentId, index),
+        isRoot: false
+      });
+    }
+  }
+  return entries;
+}
+function serializeThreadEntries(entries) {
+  return entries.map((entry) => serializeCommentEntry(entry));
+}
+function serializeCommentEntry(entry) {
+  const author = escapeAttribute3(entry.entry.authorId);
+  const createdAt = escapeAttribute3(entry.entry.createdAt);
+  const initials = entry.entry.metadata?.initials;
+  const paragraphXml = serializeCommentParagraphs(entry.entry.body, entry.paraId);
+  return `<w:comment w:id="${escapeAttribute3(entry.exportCommentId)}"${initials ? ` w:initials="${escapeAttribute3(initials)}"` : ""} w:author="${author}" w:date="${createdAt}">${paragraphXml}</w:comment>`;
+}
+function serializeCommentParagraphs(body, paraId) {
+  const paragraphs = body.length > 0 ? body.split("\n") : [""];
+  const textId = deriveTextIdFromParaId(paraId);
+  return paragraphs.map((paragraph, index) => {
+    const attributes = index === 0 ? ` w14:paraId="${escapeAttribute3(paraId)}" w14:textId="${escapeAttribute3(textId)}"` : "";
+    return `<w:p${attributes}><w:r>${serializeText2(paragraph)}</w:r></w:p>`;
+  }).join("");
+}
+function serializePreservedCommentExtensions(definitions) {
+  return definitions.map(
+    (definition) => definition.paraId ? serializePreservedCommentExtension(definition) : void 0
+  ).filter((xml) => Boolean(xml));
+}
+function serializePreservedCommentExtension(definition) {
+  const doneValue = definition.isDone ? "true" : "false";
+  return `<w15:commentEx w15:paraId="${escapeAttribute3(definition.paraId)}"${definition.parentParaId ? ` w15:paraIdParent="${escapeAttribute3(definition.parentParaId)}"` : ""} w15:done="${doneValue}" />`;
+}
+function serializeCommentExtension(entry) {
+  return `<w15:commentEx w15:paraId="${escapeAttribute3(entry.paraId)}"${entry.isRoot ? "" : ` w15:paraIdParent="${escapeAttribute3(findRootParaId(entry.thread, entry.paraId))}"`} w15:done="${entry.isRoot && entry.thread.status === "resolved" ? "true" : "false"}" />`;
+}
+function serializePreservedCommentIds(definitions) {
+  return definitions.map(
+    (definition) => definition.paraId && definition.durableId ? `<w16cid:commentId w16cid:paraId="${escapeAttribute3(definition.paraId)}" w16cid:durableId="${escapeAttribute3(definition.durableId)}" />` : void 0
+  ).filter((xml) => Boolean(xml));
+}
+function serializeCommentDurableId(entry) {
+  if (!entry.durableId) {
+    return void 0;
+  }
+  return `<w16cid:commentId w16cid:paraId="${escapeAttribute3(entry.paraId)}" w16cid:durableId="${escapeAttribute3(entry.durableId)}" />`;
+}
+function getRootEntry(thread) {
+  return thread.entries[0];
+}
+function findRootParaId(thread, fallback) {
+  return thread.entries[0]?.metadata?.paraId ?? thread.metadata?.rootParaId ?? fallback;
+}
+function generateParaId(seed, index) {
+  const normalized = `${seed}:${index}`;
+  let hash = 0;
+  for (let cursor = 0; cursor < normalized.length; cursor += 1) {
+    hash = hash * 31 + normalized.charCodeAt(cursor) >>> 0;
+  }
+  return hash.toString(16).toUpperCase().padStart(8, "0").slice(-8);
+}
+function createDurableId(entry, exportCommentId, index) {
+  const seed = `${entry.entryId}:${exportCommentId}:${index}`;
+  let hash = 0n;
+  for (let cursor = 0; cursor < seed.length; cursor += 1) {
+    hash = hash * 131n + BigInt(seed.charCodeAt(cursor)) & 0xffffffffffffffffn;
+  }
+  return hash.toString(16).toUpperCase().padStart(16, "0").slice(-16);
+}
+function deriveTextIdFromParaId(paraId) {
+  return paraId.slice(-8).padStart(8, "0");
+}
+function parseOoxmlNumericId(value) {
+  if (!/^-?\d+$/u.test(value)) {
+    return void 0;
+  }
+  const numericId = Number.parseInt(value, 10);
+  return Number.isFinite(numericId) ? numericId : void 0;
+}
+function mapParagraphBoundaries(documentXml) {
+  const root = parseXml(documentXml);
+  const documentElement = findChildElement(root, "document");
+  const bodyElement = findChildElement(documentElement, "body");
+  const paragraphs = [];
+  walkBlockNodesForParagraphBoundaries(
+    bodyElement.children,
+    documentXml,
+    paragraphs,
+    0,
+    -1,
+    true
+  );
+  return paragraphs;
+}
+function walkBlockNodesForParagraphBoundaries(nodes, documentXml, paragraphs, globalCursor, paragraphIndex, useSurfaceParagraphSeparators) {
+  let nextCursor = globalCursor;
+  let nextParagraphIndex = paragraphIndex;
+  let elementIndex = -1;
+  for (const node of nodes) {
+    if (node.type !== "element") {
+      continue;
+    }
+    elementIndex += 1;
+    const name = localName(node.name);
+    if (name === "p") {
+      if (useSurfaceParagraphSeparators && elementIndex > 0) {
+        nextCursor += 1;
+      }
+      nextParagraphIndex += 1;
+      const boundaries = /* @__PURE__ */ new Map();
+      boundaries.set(nextCursor, node.start + openingTagLength(documentXml, node.start));
+      walkParagraphForBoundaries(
+        node,
+        documentXml,
+        boundaries,
+        () => nextCursor,
+        (next) => {
+          nextCursor = next;
+        }
+      );
+      if (!boundaries.has(nextCursor)) {
+        boundaries.set(nextCursor, node.end - 4);
+      }
+      paragraphs.push({
+        paragraphIndex: nextParagraphIndex,
+        start: Math.min(...boundaries.keys()),
+        end: Math.max(...boundaries.keys()),
+        boundaries
+      });
+      continue;
+    }
+    if (name === "tbl") {
+      for (const child of node.children) {
+        if (child.type !== "element" || localName(child.name) !== "tr") {
+          continue;
+        }
+        for (const rowChild of child.children) {
+          if (rowChild.type !== "element" || localName(rowChild.name) !== "tc") {
+            continue;
+          }
+          const result = walkBlockNodesForParagraphBoundaries(
+            rowChild.children,
+            documentXml,
+            paragraphs,
+            nextCursor,
+            nextParagraphIndex,
+            false
+          );
+          nextCursor = result.globalCursor;
+          nextParagraphIndex = result.paragraphIndex;
+        }
+      }
+      continue;
+    }
+    if (name === "sdt") {
+      const sdtContent = findChildElement(node, "sdtContent");
+      const result = walkBlockNodesForParagraphBoundaries(
+        sdtContent.children,
+        documentXml,
+        paragraphs,
+        nextCursor,
+        nextParagraphIndex,
+        false
+      );
+      nextCursor = result.globalCursor;
+      nextParagraphIndex = result.paragraphIndex;
+      continue;
+    }
+    if (name === "customXml") {
+      nextCursor += 1;
+      continue;
+    }
+    nextCursor += 0;
+  }
+  return {
+    globalCursor: nextCursor,
+    paragraphIndex: nextParagraphIndex
+  };
+}
+function walkParagraphForBoundaries(paragraph, sourceXml, boundaries, getCursor, setCursor) {
+  for (const child of paragraph.children) {
+    walkInlineNodeForBoundaries(child, sourceXml, boundaries, getCursor, setCursor);
+  }
+}
+function walkInlineNodeForBoundaries(node, sourceXml, boundaries, getCursor, setCursor) {
+  if (node.type !== "element") {
+    return;
+  }
+  switch (localName(node.name)) {
+    case "r": {
+      if (!boundaries.has(getCursor())) {
+        boundaries.set(getCursor(), node.start);
+      }
+      for (const child of node.children) {
+        walkInlineNodeForBoundaries(child, sourceXml, boundaries, getCursor, setCursor);
+      }
+      boundaries.set(getCursor(), node.end);
+      return;
+    }
+    case "t": {
+      const text = node.children.filter((child) => child.type === "text").map((child) => child.text).join("");
+      setCursor(getCursor() + Array.from(text).length);
+      return;
+    }
+    case "tab":
+    case "br": {
+      const startCursor = getCursor();
+      boundaries.set(startCursor, node.start);
+      const nextCursor = startCursor + 1;
+      boundaries.set(nextCursor, node.end);
+      setCursor(nextCursor);
+      return;
+    }
+    default:
+      for (const child of node.children) {
+        walkInlineNodeForBoundaries(child, sourceXml, boundaries, getCursor, setCursor);
+      }
+  }
+}
+function pushInsertion(insertions, index, xml) {
+  const bucket = insertions.get(index);
+  if (bucket) {
+    bucket.push(xml);
+    return;
+  }
+  insertions.set(index, [xml]);
+}
+function serializeText2(text) {
+  const preserve = requiresPreservedSpace2(text) ? ` xml:space="preserve"` : "";
+  return `<w:t${preserve}>${escapeXml3(text)}</w:t>`;
+}
+function requiresPreservedSpace2(text) {
+  return /^\s/u.test(text) || /\s$/u.test(text) || /\s{2,}/u.test(text);
+}
+function escapeXml3(value) {
+  return value.replace(/&/g, "&amp;").replace(/</g, "&lt;").replace(/>/g, "&gt;");
+}
+function escapeAttribute3(value) {
+  return escapeXml3(value).replace(/"/g, "&quot;");
+}
+function openingTagLength(xml, start) {
+  const end = xml.indexOf(">", start);
+  if (end < 0) {
+    throw new Error("Malformed XML: missing tag close.");
+  }
+  return end - start + 1;
+}
+function parseXml(xml) {
+  const root = {
+    type: "element",
+    name: "#document",
+    attributes: {},
+    children: [],
+    start: 0,
+    end: xml.length
+  };
+  const stack = [root];
+  const tokenPattern = /<!--[\s\S]*?-->|<\?[\s\S]*?\?>|<!DOCTYPE[\s\S]*?>|<!\[CDATA\[[\s\S]*?\]\]>|<[^>]+>|[^<]+/gu;
+  for (const match of xml.matchAll(tokenPattern)) {
+    const token = match[0] ?? "";
+    const start = match.index ?? 0;
+    const end = start + token.length;
+    if (token.startsWith("<?") || token.startsWith("<!DOCTYPE") || token.startsWith("<!--")) {
+      continue;
+    }
+    if (token.startsWith("<![CDATA[")) {
+      const text2 = token.slice(9, -3);
+      stack[stack.length - 1]?.children.push({
+        type: "text",
+        text: text2,
+        start,
+        end
+      });
+      continue;
+    }
+    if (token.startsWith("</")) {
+      const node = stack.pop();
+      if (!node) {
+        throw new Error("Malformed XML: unexpected closing tag.");
+      }
+      node.end = end;
+      continue;
+    }
+    if (token.startsWith("<")) {
+      const selfClosing = /\/>$/.test(token);
+      const tagBody = token.slice(1, token.length - (selfClosing ? 2 : 1)).trim();
+      const { name, attributes } = parseTag(tagBody);
+      const node = {
+        type: "element",
+        name,
+        attributes,
+        children: [],
+        start,
+        end
+      };
+      stack[stack.length - 1]?.children.push(node);
+      if (!selfClosing) {
+        stack.push(node);
+      }
+      continue;
+    }
+    const text = decodeXmlText(token);
+    if (text.length > 0) {
+      stack[stack.length - 1]?.children.push({
+        type: "text",
+        text,
+        start,
+        end
+      });
+    }
+  }
+  if (stack.length !== 1) {
+    throw new Error("Malformed XML: unclosed tag.");
+  }
+  return root;
+}
+function parseTag(tagBody) {
+  const whitespaceIndex = tagBody.search(/\s/u);
+  const name = whitespaceIndex === -1 ? tagBody : tagBody.slice(0, whitespaceIndex);
+  const rawAttributes = whitespaceIndex === -1 ? "" : tagBody.slice(whitespaceIndex + 1);
+  const attributes = {};
+  const pattern = /([A-Za-z_][A-Za-z0-9:._-]*)\s*=\s*("([^"]*)"|'([^']*)')/gu;
+  for (const match of rawAttributes.matchAll(pattern)) {
+    const key = match[1];
+    const value = match[3] ?? match[4] ?? "";
+    if (key) {
+      attributes[key] = decodeXmlText(value);
+    }
+  }
+  return { name, attributes };
+}
+function findChildElement(node, name) {
+  const match = node.children.find(
+    (child) => child.type === "element" && localName(child.name) === name
+  );
+  if (!match) {
+    throw new Error(`Expected XML element ${name}.`);
+  }
+  return match;
+}
+function localName(name) {
+  const index = name.indexOf(":");
+  return index === -1 ? name : name.slice(index + 1);
+}
+function decodeXmlText(text) {
+  return text.replace(
+    /&(?:#x([0-9A-Fa-f]+)|#([0-9]+)|([A-Za-z]+));/gu,
+    (_, hex, dec, named) => {
+      if (hex) {
+        return String.fromCodePoint(Number.parseInt(hex, 16));
+      }
+      if (dec) {
+        return String.fromCodePoint(Number.parseInt(dec, 10));
+      }
+      switch (named) {
+        case "amp":
+          return "&";
+        case "lt":
+          return "<";
+        case "gt":
+          return ">";
+        case "quot":
+          return '"';
+        case "apos":
+          return "'";
+        default:
+          return `&${named};`;
+      }
+    }
+  );
+}
+
+// src/io/export/split-review-boundaries.ts
+function splitDocumentAtReviewBoundaries(content, comments, revisions) {
+  const splitPositions = collectSplitPositions(comments, revisions);
+  if (splitPositions.size === 0) {
+    return content;
+  }
+  return {
+    type: "doc",
+    children: splitBlockNodes(content.children, splitPositions, 0, true).children
+  };
+}
+function collectSplitPositions(comments, revisions) {
+  const positions = /* @__PURE__ */ new Set();
+  for (const thread of comments) {
+    if (thread.anchor.kind !== "range") {
+      continue;
+    }
+    positions.add(thread.anchor.range.from);
+    positions.add(thread.anchor.range.to);
+  }
+  for (const revision of revisions) {
+    if (revision.status !== "active" || revision.anchor.kind !== "range") {
+      continue;
+    }
+    if (revision.metadata.importedRevisionForm === "paragraph-insertion" || revision.metadata.importedRevisionForm === "paragraph-deletion") {
+      continue;
+    }
+    positions.add(revision.anchor.range.from);
+    positions.add(revision.anchor.range.to);
+  }
+  return positions;
+}
+function splitParagraph(paragraph, splitPositions, cursor) {
+  const children = [];
+  let nextCursor = cursor;
+  for (const child of paragraph.children) {
+    if (child.type === "text") {
+      const split = splitTextNode(child, splitPositions, nextCursor);
+      children.push(...split.children);
+      nextCursor = split.cursor;
+      continue;
+    }
+    if (child.type === "hyperlink") {
+      const split = splitHyperlinkNode(child, splitPositions, nextCursor);
+      children.push(...split.children);
+      nextCursor = split.cursor;
+      continue;
+    }
+    children.push(child);
+    nextCursor += measureInlineNodeForReviewBoundaries(child);
+  }
+  return {
+    paragraph: {
+      ...paragraph,
+      children
+    },
+    cursor: nextCursor
+  };
+}
+function splitBlockNodes(blocks, splitPositions, cursor, useSurfaceParagraphSeparators) {
+  const children = [];
+  let nextCursor = cursor;
+  for (const [index, block] of blocks.entries()) {
+    if (block.type === "paragraph") {
+      if (useSurfaceParagraphSeparators && index > 0) {
+        nextCursor += 1;
+      }
+      const next = splitParagraph(block, splitPositions, nextCursor);
+      children.push(next.paragraph);
+      nextCursor = next.cursor;
+      continue;
+    }
+    if (block.type === "table") {
+      const next = splitTableAtReviewBoundaries(block, splitPositions, nextCursor);
+      children.push(next.table);
+      nextCursor = next.cursor;
+      continue;
+    }
+    if (block.type === "sdt") {
+      const next = splitBlockNodes(block.children, splitPositions, nextCursor, false);
+      children.push({
+        ...block,
+        children: next.children
+      });
+      nextCursor = next.cursor;
+      continue;
+    }
+    if (block.type === "custom_xml") {
+      children.push(block);
+      nextCursor += 1;
+      continue;
+    }
+    children.push(block);
+    nextCursor += 1;
+  }
+  return {
+    children,
+    cursor: nextCursor
+  };
+}
+function splitTableAtReviewBoundaries(table, splitPositions, cursor) {
+  let nextCursor = cursor;
+  const rows = table.rows.map((row) => ({
+    ...row,
+    cells: row.cells.map((cell) => {
+      const next = splitBlockNodes(cell.children, splitPositions, nextCursor, false);
+      nextCursor = next.cursor;
+      return {
+        ...cell,
+        children: next.children
+      };
+    })
+  }));
+  return {
+    table: {
+      ...table,
+      rows
+    },
+    cursor: nextCursor
+  };
+}
+function splitHyperlinkNode(node, splitPositions, cursor) {
+  let nextCursor = cursor;
+  const groups = [[]];
+  for (const child of node.children) {
+    if (child.type === "text") {
+      const split = splitTextNode(child, splitPositions, nextCursor);
+      for (const piece of split.children) {
+        groups[groups.length - 1]?.push(piece);
+        nextCursor += Array.from(piece.text).length;
+        if (splitPositions.has(nextCursor)) {
+          groups.push([]);
+        }
+      }
+      continue;
+    }
+    groups[groups.length - 1]?.push(child);
+    nextCursor += measureInlineNodeForReviewBoundaries(child);
+    if (splitPositions.has(nextCursor)) {
+      groups.push([]);
+    }
+  }
+  const hyperlinks = groups.filter((children) => children.length > 0).map((children) => ({
+    type: "hyperlink",
+    href: node.href,
+    children
+  }));
+  return {
+    children: hyperlinks.length > 0 ? hyperlinks : [node],
+    cursor: nextCursor
+  };
+}
+function splitTextNode(node, splitPositions, cursor) {
+  const codepoints = Array.from(node.text);
+  if (codepoints.length === 0) {
+    return { children: [], cursor };
+  }
+  const boundaries = /* @__PURE__ */ new Set([0, codepoints.length]);
+  for (let index = 1; index < codepoints.length; index += 1) {
+    if (splitPositions.has(cursor + index)) {
+      boundaries.add(index);
+    }
+  }
+  const ordered = [...boundaries].sort((left, right) => left - right);
+  const children = [];
+  for (let index = 0; index < ordered.length - 1; index += 1) {
+    const start = ordered[index] ?? 0;
+    const end = ordered[index + 1] ?? codepoints.length;
+    const text = codepoints.slice(start, end).join("");
+    if (text.length === 0) {
+      continue;
+    }
+    children.push({
+      type: "text",
+      text,
+      ...node.marks && node.marks.length > 0 ? { marks: node.marks } : {}
+    });
+  }
+  return {
+    children: children.length > 0 ? children : [node],
+    cursor: cursor + codepoints.length
+  };
+}
+function measureInlineNodeForReviewBoundaries(node) {
+  switch (node.type) {
+    case "text":
+      return Array.from(node.text).length;
+    case "bookmark_start":
+    case "bookmark_end":
+      return 0;
+    case "hyperlink":
+      return node.children.reduce(
+        (size, child) => size + measureInlineNodeForReviewBoundaries(child),
+        0
+      );
+    case "field": {
+      const childWidth = node.children.reduce(
+        (size, child) => size + measureInlineNodeForReviewBoundaries(child),
+        0
+      );
+      return childWidth > 0 ? childWidth : 1;
+    }
+    case "tab":
+    case "hard_break":
+    case "column_break":
+    case "footnote_ref":
+    case "image":
+    case "opaque_inline":
+    case "chart_preview":
+    case "smartart_preview":
+    case "shape":
+    case "wordart":
+    case "vml_shape":
+    case "symbol":
+      return 1;
+    default:
+      return 1;
+  }
+}
+
+// src/io/ooxml/revision-boundaries.ts
+function mapRevisionBoundaries(documentXml) {
+  const root = parseXmlWithPositions(documentXml);
+  const documentElement = findRequiredChildElement(root, "document");
+  const bodyElement = findRequiredChildElement(documentElement, "body");
+  const paragraphs = [];
+  let cursor = 0;
+  let paragraphIndex = -1;
+  let previousWasParagraph = false;
+  for (const child of bodyElement.children) {
+    if (child.type !== "element") {
+      continue;
+    }
+    if (localName2(child.name) !== "p") {
+      cursor += 1;
+      previousWasParagraph = false;
+      continue;
+    }
+    if (previousWasParagraph) {
+      cursor += 1;
+    }
+    paragraphIndex += 1;
+    const boundaries = /* @__PURE__ */ new Map();
+    boundaries.set(cursor, child.openingTagEnd);
+    const paragraphProperties = findChildElement2(child, "pPr");
+    const paragraphRunProperties = paragraphProperties ? findChildElement2(paragraphProperties, "rPr") : void 0;
+    walkStoryNodesForBoundaries(
+      child.children,
+      boundaries,
+      () => cursor,
+      (next) => {
+        cursor = next;
+      }
+    );
+    boundaries.set(cursor, child.closingTagStart);
+    paragraphs.push({
+      paragraphIndex,
+      start: Math.min(...boundaries.keys()),
+      end: Math.max(...boundaries.keys()),
+      boundaries,
+      paragraphStart: child.start,
+      paragraphStartTagEnd: child.openingTagEnd,
+      paragraphEndTagStart: child.closingTagStart,
+      paragraphEnd: child.end,
+      ...paragraphProperties ? {
+        paragraphPropertiesStart: paragraphProperties.start,
+        paragraphPropertiesEnd: paragraphProperties.end
+      } : {},
+      ...paragraphRunProperties ? {
+        paragraphRunPropertiesStart: paragraphRunProperties.start,
+        paragraphRunPropertiesEnd: paragraphRunProperties.end
+      } : {}
+    });
+    previousWasParagraph = true;
+  }
+  return paragraphs;
+}
+function walkStoryNodesForBoundaries(nodes, boundaries, getCursor, setCursor) {
+  for (const node of nodes) {
+    walkStoryNodeForBoundaries(node, boundaries, getCursor, setCursor);
+  }
+}
+function walkStoryNodeForBoundaries(node, boundaries, getCursor, setCursor) {
+  if (node.type !== "element") {
+    return;
+  }
+  switch (localName2(node.name)) {
+    case "pPr":
+      return;
+    case "r":
+      boundaries.set(getCursor(), node.start);
+      for (const child of node.children) {
+        walkStoryNodeForBoundaries(child, boundaries, getCursor, setCursor);
+      }
+      boundaries.set(getCursor(), node.end);
+      return;
+    case "ins":
+    case "del":
+    case "moveFrom":
+    case "moveTo":
+    case "hyperlink":
+    case "smartTag":
+    case "sdtContent":
+    case "customXml":
+      for (const child of node.children) {
+        walkStoryNodeForBoundaries(child, boundaries, getCursor, setCursor);
+      }
+      return;
+    case "t":
+    case "delText":
+    case "instrText":
+    case "delInstrText": {
+      const text = node.children.filter((child) => child.type === "text").map((child) => child.text).join("");
+      if (text.length === 0) {
+        return;
+      }
+      if (!boundaries.has(getCursor())) {
+        boundaries.set(getCursor(), node.start);
+      }
+      setCursor(getCursor() + text.length);
+      boundaries.set(getCursor(), node.end);
+      return;
+    }
+    case "tab":
+    case "br":
+    case "cr":
+      if (!boundaries.has(getCursor())) {
+        boundaries.set(getCursor(), node.start);
+      }
+      setCursor(getCursor() + 1);
+      boundaries.set(getCursor(), node.end);
+      return;
+    default:
+      for (const child of node.children) {
+        walkStoryNodeForBoundaries(child, boundaries, getCursor, setCursor);
+      }
+  }
+}
+function parseXmlWithPositions(xml) {
+  const root = {
+    type: "element",
+    name: "__root__",
+    attributes: {},
+    children: [],
+    start: 0,
+    end: xml.length,
+    openingTagEnd: 0,
+    closingTagStart: xml.length
+  };
+  const stack = [root];
+  let cursor = 0;
+  while (cursor < xml.length) {
+    if (xml.startsWith("<!--", cursor)) {
+      const end = xml.indexOf("-->", cursor);
+      cursor = end >= 0 ? end + 3 : xml.length;
+      continue;
+    }
+    if (xml.startsWith("<?", cursor)) {
+      const end = xml.indexOf("?>", cursor);
+      cursor = end >= 0 ? end + 2 : xml.length;
+      continue;
+    }
+    if (xml.startsWith("<![CDATA[", cursor)) {
+      const end = xml.indexOf("]]>", cursor);
+      const textEnd = end >= 0 ? end : xml.length;
+      stack[stack.length - 1]?.children.push({
+        type: "text",
+        text: xml.slice(cursor + 9, textEnd),
+        start: cursor,
+        end: textEnd
+      });
+      cursor = end >= 0 ? end + 3 : xml.length;
+      continue;
+    }
+    if (xml[cursor] !== "<") {
+      const nextTag = xml.indexOf("<", cursor);
+      const end = nextTag >= 0 ? nextTag : xml.length;
+      const text = decodeXmlEntities2(xml.slice(cursor, end));
+      if (text.length > 0) {
+        stack[stack.length - 1]?.children.push({
+          type: "text",
+          text,
+          start: cursor,
+          end
+        });
+      }
+      cursor = end;
+      continue;
+    }
+    if (xml[cursor + 1] === "/") {
+      const tagEnd2 = xml.indexOf(">", cursor);
+      if (tagEnd2 < 0) {
+        throw new Error("Malformed XML: unterminated closing tag.");
+      }
+      const node2 = stack.pop();
+      if (!node2 || stack.length === 0) {
+        throw new Error("Malformed XML: unexpected closing tag.");
+      }
+      node2.closingTagStart = cursor;
+      node2.end = tagEnd2 + 1;
+      cursor = tagEnd2 + 1;
+      continue;
+    }
+    const tagEnd = xml.indexOf(">", cursor);
+    if (tagEnd < 0) {
+      throw new Error("Malformed XML: unterminated opening tag.");
+    }
+    const rawTag = xml.slice(cursor + 1, tagEnd);
+    const selfClosing = /\/\s*$/.test(rawTag);
+    const normalizedTag = selfClosing ? rawTag.replace(/\/\s*$/, "") : rawTag;
+    const parts = normalizedTag.trim().split(/\s+/, 1);
+    const name = parts[0];
+    if (!name) {
+      throw new Error("Malformed XML: empty tag name.");
+    }
+    const attributes = parseAttributes2(normalizedTag.slice(name.length));
+    const node = {
+      type: "element",
+      name,
+      attributes,
+      children: [],
+      start: cursor,
+      end: selfClosing ? tagEnd + 1 : xml.length,
+      openingTagEnd: tagEnd + 1,
+      closingTagStart: tagEnd + 1
+    };
+    stack[stack.length - 1]?.children.push(node);
+    cursor = tagEnd + 1;
+    if (!selfClosing) {
+      stack.push(node);
+    }
+  }
+  if (stack.length !== 1) {
+    throw new Error("Malformed XML: unclosed element.");
+  }
+  return root;
+}
+function findRequiredChildElement(node, childLocalName) {
+  const child = findChildElement2(node, childLocalName);
+  if (!child) {
+    throw new Error(`Expected <${childLocalName}> element.`);
+  }
+  return child;
+}
+function findChildElement2(node, childLocalName) {
+  return node.children.find(
+    (entry) => entry.type === "element" && localName2(entry.name) === childLocalName
+  );
+}
+function localName2(name) {
+  const separatorIndex = name.indexOf(":");
+  return separatorIndex >= 0 ? name.slice(separatorIndex + 1) : name;
+}
+function parseAttributes2(source) {
+  const attributes = {};
+  const attributePattern = /([A-Za-z_][A-Za-z0-9:._-]*)\s*=\s*("([^"]*)"|'([^']*)')/g;
+  for (const match of source.matchAll(attributePattern)) {
+    const key = match[1];
+    if (!key) {
+      continue;
+    }
+    const rawValue = match[3] ?? match[4] ?? "";
+    attributes[key] = decodeXmlEntities2(rawValue);
+  }
+  return attributes;
+}
+function decodeXmlEntities2(value) {
+  return value.replace(/&lt;/g, "<").replace(/&gt;/g, ">").replace(/&quot;/g, '"').replace(/&apos;/g, "'").replace(/&amp;/g, "&");
+}
+
+// src/io/export/serialize-runtime-revisions.ts
+function serializeRuntimeRevisionsIntoDocumentXml(documentXml, revisions, boundaries = mapRevisionBoundaries(documentXml)) {
+  const replacements = [];
+  const serializedRevisionIds = [];
+  const skippedRevisionIds = [];
+  const paragraphMarkers = /* @__PURE__ */ new Map();
+  for (const revision of revisions) {
+    if (revision.status !== "active" || revision.anchor.kind !== "range") {
+      continue;
+    }
+    if (revision.kind !== "insertion" && revision.kind !== "deletion") {
+      continue;
+    }
+    const form = revision.metadata.importedRevisionForm;
+    if (form === "paragraph-insertion" || form === "paragraph-deletion") {
+      const paragraphBoundary = findParagraphBoundaryForAnchor(boundaries, revision);
+      if (!paragraphBoundary) {
+        skippedRevisionIds.push(revision.revisionId);
+        continue;
+      }
+      const entry = paragraphMarkers.get(paragraphBoundary.paragraphIndex) ?? {
+        boundary: paragraphBoundary,
+        markers: [],
+        revisionIds: []
+      };
+      entry.markers.push(createParagraphRevisionMarker(revision));
+      entry.revisionIds.push(revision.revisionId);
+      paragraphMarkers.set(paragraphBoundary.paragraphIndex, entry);
+      serializedRevisionIds.push(revision.revisionId);
+      continue;
+    }
+    const rangeReplacement = createRangeRevisionReplacement(documentXml, boundaries, revision);
+    if (!rangeReplacement) {
+      skippedRevisionIds.push(revision.revisionId);
+      continue;
+    }
+    replacements.push(rangeReplacement);
+    serializedRevisionIds.push(revision.revisionId);
+  }
+  for (const { boundary, markers, revisionIds } of paragraphMarkers.values()) {
+    const paragraphInsertion = createParagraphRevisionInsertion(
+      documentXml,
+      boundary,
+      markers
+    );
+    if (!paragraphInsertion) {
+      skippedRevisionIds.push(...revisionIds);
+      continue;
+    }
+    replacements.push(paragraphInsertion);
+  }
+  return {
+    documentXml: applyReplacements(documentXml, replacements),
+    serializedRevisionIds,
+    skippedRevisionIds
+  };
+}
+function createRangeRevisionReplacement(documentXml, boundaries, revision) {
+  const { anchor } = revision;
+  if (anchor.kind !== "range") {
+    return void 0;
+  }
+  const paragraphBoundary = findParagraphBoundaryForRange(boundaries, anchor.range.from, anchor.range.to);
+  if (!paragraphBoundary) {
+    return void 0;
+  }
+  const startIndex = paragraphBoundary.boundaries.get(anchor.range.from);
+  const endIndex = paragraphBoundary.boundaries.get(anchor.range.to);
+  if (startIndex === void 0 || endIndex === void 0 || endIndex < startIndex) {
+    return void 0;
+  }
+  const xml = documentXml.slice(startIndex, endIndex);
+  const attributes = serializeRevisionAttributes(revision);
+  return {
+    start: startIndex,
+    end: endIndex,
+    replacement: revision.kind === "insertion" ? `<w:ins${attributes}>${xml}</w:ins>` : `<w:del${attributes}>${convertRunsToDeletedContent(xml)}</w:del>`
+  };
+}
+function createParagraphRevisionMarker(revision) {
+  const markerName = revision.kind === "insertion" ? "w:ins" : "w:del";
+  return `<${markerName}${serializeRevisionAttributes(revision)}/>`;
+}
+function createParagraphRevisionInsertion(documentXml, paragraphBoundary, markers) {
+  const paragraphXml = documentXml.slice(
+    paragraphBoundary.paragraphStart,
+    paragraphBoundary.paragraphEnd
+  );
+  const markerXml = markers.join("");
+  const paragraphRunPropertiesInsertionIndex = findClosingTagInsertionIndex(
+    documentXml,
+    paragraphBoundary.paragraphRunPropertiesStart,
+    paragraphBoundary.paragraphRunPropertiesEnd,
+    "w:rPr"
+  );
+  if (paragraphRunPropertiesInsertionIndex !== void 0) {
+    return {
+      start: paragraphRunPropertiesInsertionIndex,
+      end: paragraphRunPropertiesInsertionIndex,
+      replacement: markerXml
+    };
+  }
+  const paragraphPropertiesInsertionIndex = findClosingTagInsertionIndex(
+    documentXml,
+    paragraphBoundary.paragraphPropertiesStart,
+    paragraphBoundary.paragraphPropertiesEnd,
+    "w:pPr"
+  );
+  if (paragraphPropertiesInsertionIndex !== void 0) {
+    return {
+      start: paragraphPropertiesInsertionIndex,
+      end: paragraphPropertiesInsertionIndex,
+      replacement: `<w:rPr>${markerXml}</w:rPr>`
+    };
+  }
+  if (!/<w:p[\s>]/u.test(paragraphXml)) {
+    return void 0;
+  }
+  return {
+    start: paragraphBoundary.paragraphStartTagEnd,
+    end: paragraphBoundary.paragraphStartTagEnd,
+    replacement: `<w:pPr><w:rPr>${markerXml}</w:rPr></w:pPr>`
+  };
+}
+function findParagraphBoundaryForRange(boundaries, from, to) {
+  return boundaries.find(
+    (boundary) => from >= boundary.start && to <= boundary.end
+  );
+}
+function findParagraphBoundaryForAnchor(boundaries, revision) {
+  const anchor = revision.anchor.kind === "range" ? revision.anchor.range.from : void 0;
+  if (anchor === void 0) {
+    return void 0;
+  }
+  return boundaries.find(
+    (boundary) => boundary.end === anchor || anchor >= boundary.start && anchor <= boundary.end
+  );
+}
+function serializeRevisionAttributes(revision) {
+  const attributes = {
+    "w:id": revision.metadata.ooxmlRevisionId ?? sanitizeRevisionId(revision.revisionId),
+    "w:author": revision.authorId,
+    "w:date": revision.createdAt
+  };
+  return Object.entries(attributes).filter(([, value]) => value && value.length > 0).map(([name, value]) => ` ${name}="${escapeAttribute4(value)}"`).join("");
+}
+function findClosingTagInsertionIndex(documentXml, start, end, tagName) {
+  if (start === void 0 || end === void 0) {
+    return void 0;
+  }
+  const closingTag = `</${tagName}>`;
+  const closingIndex = documentXml.lastIndexOf(closingTag, end);
+  if (closingIndex < start) {
+    return void 0;
+  }
+  return closingIndex;
+}
+function sanitizeRevisionId(revisionId) {
+  const numericTail = /(\d+)$/.exec(revisionId)?.[1];
+  return numericTail ?? revisionId.replace(/[^A-Za-z0-9._-]/g, "-");
+}
+function convertRunsToDeletedContent(xml) {
+  return xml.replace(/<(\/?)w:t\b/g, "<$1w:delText").replace(/<(\/?)w:instrText\b/g, "<$1w:delInstrText");
+}
+function applyReplacements(documentXml, replacements) {
+  const sorted = replacements.slice().sort((left, right) => right.start - left.start || right.end - left.end);
+  let output = documentXml;
+  for (const replacement of sorted) {
+    output = output.slice(0, replacement.start) + replacement.replacement + output.slice(replacement.end);
+  }
+  return output;
+}
+function escapeAttribute4(value) {
+  return value.replace(/&/g, "&amp;").replace(/</g, "&lt;").replace(/>/g, "&gt;").replace(/"/g, "&quot;");
+}
+
+export {
+  DOCX_MIME_TYPE,
+  DOCX_DOCUMENT_CONTENT_TYPE,
+  writeDocxPackage,
+  readOpcPackage,
+  createExportSession,
+  DOCX_NULL_NUMBERING_INSTANCE_ID,
+  createSyntheticDocxNullNumberingCatalog,
+  WORD_NUMBERING_CONTENT_TYPE,
+  serializeNumberingXml,
+  hasSerializableNumberingEntries,
+  serializeMainDocument,
+  mapRevisionBoundaries,
+  parseXmlWithPositions,
+  findRequiredChildElement,
+  findChildElement2 as findChildElement,
+  localName2 as localName,
+  serializeMergedCommentsXml,
+  serializeCommentAnchorsIntoDocumentXml,
+  createCommentExportIdMap,
+  mapParagraphBoundaries,
+  splitDocumentAtReviewBoundaries,
+  serializeRuntimeRevisionsIntoDocumentXml
+};
+//# sourceMappingURL=chunk-WGBAKP3Q.js.map