@beyondwork/docx-react-component 1.0.27 → 1.0.29

package/dist/chunk-4AQOYAW4.js

@@ -0,0 +1,3069 @@
+import {
+  normalizePartPath,
+  resolveRelationshipTarget
+} from "./chunk-FUDY333O.js";
+import {
+  classifyFieldInstruction
+} from "./chunk-TLCEAQDQ.js";
+
+// src/io/ooxml/parse-numbering.ts
+function parseNumberingXml(xml) {
+  const root = parseXml(xml);
+  const numberingElement = findChildElement(root, "numbering");
+  const abstractDefinitions = {};
+  const instances = {};
+  for (const child of numberingElement.children) {
+    if (child.type !== "element") {
+      continue;
+    }
+    switch (localName(child.name)) {
+      case "abstractNum": {
+        const rawId = child.attributes["w:abstractNumId"] ?? child.attributes.abstractNumId;
+        if (!rawId) {
+          continue;
+        }
+        const abstractNumberingId = toCanonicalAbstractNumberingId(rawId);
+        abstractDefinitions[abstractNumberingId] = {
+          abstractNumberingId,
+          levels: readLevels(child)
+        };
+        break;
+      }
+      case "num": {
+        const rawId = child.attributes["w:numId"] ?? child.attributes.numId;
+        const abstractReference = findChildElementOptional(child, "abstractNumId");
+        const rawAbstractId = abstractReference?.attributes["w:val"] ?? abstractReference?.attributes.val;
+        if (!rawId || !rawAbstractId) {
+          continue;
+        }
+        const numberingInstanceId = toCanonicalNumberingInstanceId(rawId);
+        instances[numberingInstanceId] = {
+          numberingInstanceId,
+          abstractNumberingId: toCanonicalAbstractNumberingId(rawAbstractId),
+          overrides: readOverrides(child)
+        };
+        break;
+      }
+    }
+  }
+  return {
+    abstractDefinitions,
+    instances
+  };
+}
+function toCanonicalAbstractNumberingId(value) {
+  return value.startsWith("abstract-num:") ? value : `abstract-num:${value}`;
+}
+function toCanonicalNumberingInstanceId(value) {
+  return value.startsWith("num:") ? value : `num:${value}`;
+}
+function readLevels(abstractNode) {
+  const levels = [];
+  for (const child of abstractNode.children) {
+    if (child.type !== "element" || localName(child.name) !== "lvl") {
+      continue;
+    }
+    const rawLevel = child.attributes["w:ilvl"] ?? child.attributes.ilvl;
+    const level = rawLevel === void 0 ? void 0 : parseInteger(rawLevel);
+    if (level === void 0) {
+      continue;
+    }
+    const startNode = findChildElementOptional(child, "start");
+    const formatNode = findChildElementOptional(child, "numFmt");
+    const textNode = findChildElementOptional(child, "lvlText");
+    const paragraphStyleNode = findChildElementOptional(child, "pStyle");
+    const rawStart = startNode?.attributes["w:val"] ?? startNode?.attributes.val;
+    const startAt = rawStart === void 0 ? void 0 : parseInteger(rawStart);
+    const format = formatNode?.attributes["w:val"] ?? formatNode?.attributes.val ?? "decimal";
+    const text = textNode?.attributes["w:val"] ?? textNode?.attributes.val ?? `%${level + 1}.`;
+    const paragraphStyleId = paragraphStyleNode?.attributes["w:val"] ?? paragraphStyleNode?.attributes.val;
+    const isLegalNode = findChildElementOptional(child, "isLgl");
+    const isLegalNumbering = isLegalNode !== void 0;
+    const suffixNode = findChildElementOptional(child, "suff");
+    const suffixVal = suffixNode?.attributes["w:val"] ?? suffixNode?.attributes.val;
+    const suffix = suffixVal === "space" || suffixVal === "nothing" ? suffixVal : suffixVal === "tab" ? "tab" : void 0;
+    levels.push({
+      level,
+      format,
+      text,
+      ...startAt !== void 0 ? { startAt } : {},
+      ...paragraphStyleId ? { paragraphStyleId } : {},
+      ...isLegalNumbering ? { isLegalNumbering } : {},
+      ...suffix ? { suffix } : {}
+    });
+  }
+  return levels.sort((left, right) => left.level - right.level);
+}
+function readOverrides(numNode) {
+  const overrides = [];
+  for (const child of numNode.children) {
+    if (child.type !== "element" || localName(child.name) !== "lvlOverride") {
+      continue;
+    }
+    const rawLevel = child.attributes["w:ilvl"] ?? child.attributes.ilvl;
+    const level = rawLevel === void 0 ? void 0 : parseInteger(rawLevel);
+    if (level === void 0) {
+      continue;
+    }
+    const startOverrideNode = findChildElementOptional(child, "startOverride");
+    const rawStart = startOverrideNode?.attributes["w:val"] ?? startOverrideNode?.attributes.val;
+    const startAt = rawStart === void 0 ? void 0 : parseInteger(rawStart);
+    overrides.push({
+      level,
+      ...startAt !== void 0 ? { startAt } : {}
+    });
+  }
+  return overrides.sort((left, right) => left.level - right.level);
+}
+function findChildElement(node, childLocalName) {
+  const child = findChildElementOptional(node, childLocalName);
+  if (!child) {
+    throw new Error(`Expected <${childLocalName}> element in numbering XML.`);
+  }
+  return child;
+}
+function findChildElementOptional(node, childLocalName) {
+  return node.children.find(
+    (entry) => entry.type === "element" && localName(entry.name) === childLocalName
+  );
+}
+function localName(name) {
+  const separatorIndex = name.indexOf(":");
+  return separatorIndex >= 0 ? name.slice(separatorIndex + 1) : name;
+}
+function parseInteger(value) {
+  if (!/^-?\d+$/.test(value)) {
+    return void 0;
+  }
+  return Number.parseInt(value, 10);
+}
+function parseXml(xml) {
+  const root = {
+    type: "element",
+    name: "__root__",
+    attributes: {},
+    children: []
+  };
+  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)
+      });
+      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 = decodeXmlEntities(xml.slice(cursor, end));
+      if (text.length > 0) {
+        stack[stack.length - 1]?.children.push({
+          type: "text",
+          text
+        });
+      }
+      cursor = end;
+      continue;
+    }
+    if (xml[cursor + 1] === "/") {
+      const end = xml.indexOf(">", cursor);
+      if (end < 0) {
+        throw new Error("Malformed XML: missing closing >.");
+      }
+      const name2 = xml.slice(cursor + 2, end).trim();
+      const current = stack.pop();
+      if (!current || localName(current.name) !== localName(name2)) {
+        throw new Error(`Malformed XML: unexpected closing tag </${name2}>.`);
+      }
+      cursor = end + 1;
+      continue;
+    }
+    const tagEnd = findTagEnd(xml, cursor);
+    const tagBody = xml.slice(cursor + 1, tagEnd);
+    const selfClosing = /\/\s*$/.test(tagBody);
+    const { name, attributes } = parseTag(tagBody.replace(/\/\s*$/, "").trim());
+    const element = {
+      type: "element",
+      name,
+      attributes,
+      children: []
+    };
+    stack[stack.length - 1]?.children.push(element);
+    if (!selfClosing) {
+      stack.push(element);
+    }
+    cursor = tagEnd + 1;
+  }
+  if (stack.length !== 1) {
+    throw new Error("Malformed XML: unclosed element.");
+  }
+  return root;
+}
+function parseTag(tagBody) {
+  let cursor = 0;
+  while (cursor < tagBody.length && /\s/.test(tagBody[cursor] ?? "")) {
+    cursor += 1;
+  }
+  const nameStart = cursor;
+  while (cursor < tagBody.length && !/\s/.test(tagBody[cursor] ?? "")) {
+    cursor += 1;
+  }
+  const name = tagBody.slice(nameStart, cursor);
+  const attributes = {};
+  while (cursor < tagBody.length) {
+    while (cursor < tagBody.length && /\s/.test(tagBody[cursor] ?? "")) {
+      cursor += 1;
+    }
+    if (cursor >= tagBody.length) {
+      break;
+    }
+    const keyStart = cursor;
+    while (cursor < tagBody.length && !/[\s=]/.test(tagBody[cursor] ?? "")) {
+      cursor += 1;
+    }
+    const key = tagBody.slice(keyStart, cursor);
+    while (cursor < tagBody.length && /\s/.test(tagBody[cursor] ?? "")) {
+      cursor += 1;
+    }
+    if (tagBody[cursor] !== "=") {
+      attributes[key] = "";
+      continue;
+    }
+    cursor += 1;
+    while (cursor < tagBody.length && /\s/.test(tagBody[cursor] ?? "")) {
+      cursor += 1;
+    }
+    const quote = tagBody[cursor];
+    if (quote !== `"` && quote !== `'`) {
+      throw new Error(`Malformed XML attribute ${key}.`);
+    }
+    cursor += 1;
+    const valueStart = cursor;
+    while (cursor < tagBody.length && tagBody[cursor] !== quote) {
+      cursor += 1;
+    }
+    const rawValue = tagBody.slice(valueStart, cursor);
+    attributes[key] = decodeXmlEntities(rawValue);
+    cursor += 1;
+  }
+  return { name, attributes };
+}
+function findTagEnd(xml, start) {
+  let cursor = start + 1;
+  let quote = null;
+  while (cursor < xml.length) {
+    const current = xml[cursor];
+    if (quote) {
+      if (current === quote) {
+        quote = null;
+      }
+      cursor += 1;
+      continue;
+    }
+    if (current === `"` || current === `'`) {
+      quote = current;
+      cursor += 1;
+      continue;
+    }
+    if (current === ">") {
+      return cursor;
+    }
+    cursor += 1;
+  }
+  throw new Error("Malformed XML: missing >.");
+}
+function decodeXmlEntities(value) {
+  return value.replace(/&(#x[0-9a-fA-F]+|#\d+|amp|lt|gt|quot|apos);/g, (match, entity) => {
+    switch (entity) {
+      case "amp":
+        return "&";
+      case "lt":
+        return "<";
+      case "gt":
+        return ">";
+      case "quot":
+        return `"`;
+      case "apos":
+        return "'";
+      default:
+        if (entity.startsWith("#x")) {
+          return String.fromCodePoint(Number.parseInt(entity.slice(2), 16));
+        }
+        if (entity.startsWith("#")) {
+          return String.fromCodePoint(Number.parseInt(entity.slice(1), 10));
+        }
+        return match;
+    }
+  });
+}
+
+// src/io/ooxml/parse-inline-media.ts
+function parseInlineMediaXml(xml, relationships, mediaParts = /* @__PURE__ */ new Map(), sourcePartPath = "/word/document.xml") {
+  const root = parseXml2(xml);
+  const relationshipMap = new Map(relationships.map((relationship) => [relationship.id, relationship]));
+  const drawings = findDescendants(root, "drawing");
+  const media = [];
+  for (const drawing of drawings) {
+    const inline = findFirstDescendant(drawing, "inline");
+    const anchor = findFirstDescendant(drawing, "anchor");
+    const container = anchor ?? inline;
+    const blip = findFirstDescendant(drawing, "blip");
+    if (!container || !blip) {
+      continue;
+    }
+    const relationshipId = blip.attributes["r:embed"] ?? blip.attributes.embed;
+    if (!relationshipId) {
+      continue;
+    }
+    const relationship = relationshipMap.get(relationshipId);
+    if (!relationship || !relationship.type.endsWith("/image")) {
+      continue;
+    }
+    const packagePartName = normalizePartPath(
+      resolveRelationshipTarget(sourcePartPath, relationship)
+    );
+    const mediaPart = mediaParts.get(packagePartName);
+    const docProperties = findFirstDescendant(container, "docPr");
+    const altText = readAltText(docProperties);
+    const floating = anchor ? readFloatingProperties(anchor) : void 0;
+    const extent = findDrawingExtent(container);
+    const widthEmu = extent ? readEmuAttribute(extent, "cx") : void 0;
+    const heightEmu = extent ? readEmuAttribute(extent, "cy") : void 0;
+    media.push({
+      type: "image",
+      mediaId: `media:${packagePartName.slice(1)}`,
+      relationshipId,
+      packagePartName,
+      ...mediaPart ? { contentType: mediaPart.contentType } : {},
+      filename: packagePartName.slice(packagePartName.lastIndexOf("/") + 1),
+      ...altText ? { altText } : {},
+      ...widthEmu !== void 0 ? { widthEmu } : {},
+      ...heightEmu !== void 0 ? { heightEmu } : {},
+      ...anchor ? { display: "floating" } : {},
+      ...floating ? { floating } : {}
+    });
+  }
+  return media;
+}
+function findDrawingExtent(node) {
+  const wordProcessingExtent = findFirstDescendant(node, "extent");
+  if (wordProcessingExtent) {
+    return wordProcessingExtent;
+  }
+  const transform = findFirstDescendant(node, "xfrm");
+  if (!transform) {
+    return void 0;
+  }
+  return findFirstDescendant(transform, "ext");
+}
+function readFloatingProperties(node) {
+  const horizontalPosition = findFirstDescendant(node, "positionH");
+  const verticalPosition = findFirstDescendant(node, "positionV");
+  const wrap = findFirstDescendant(node, "wrapNone") ?? findFirstDescendant(node, "wrapSquare") ?? findFirstDescendant(node, "wrapTight") ?? findFirstDescendant(node, "wrapThrough") ?? findFirstDescendant(node, "wrapTopAndBottom");
+  const properties = {};
+  const horizontalAxis = readAxisPosition(horizontalPosition);
+  const verticalAxis = readAxisPosition(verticalPosition);
+  if (horizontalAxis) {
+    properties.horizontalPosition = horizontalAxis;
+  }
+  if (verticalAxis) {
+    properties.verticalPosition = verticalAxis;
+  }
+  if (wrap) {
+    const wrapName = localName2(wrap.name);
+    properties.wrap = wrapName === "wrapSquare" ? "square" : wrapName === "wrapTight" ? "tight" : wrapName === "wrapThrough" ? "through" : wrapName === "wrapTopAndBottom" ? "topAndBottom" : "none";
+  }
+  properties.behindDoc = readBooleanAttribute(node, "behindDoc");
+  properties.layoutInCell = readBooleanAttribute(node, "layoutInCell");
+  properties.allowOverlap = readBooleanAttribute(node, "allowOverlap");
+  return Object.values(properties).some((value) => value !== void 0) ? properties : void 0;
+}
+function readAxisPosition(node) {
+  if (!node) {
+    return void 0;
+  }
+  const align = findFirstDescendant(node, "align");
+  const posOffset = findFirstDescendant(node, "posOffset");
+  const position = {
+    ...readOptionalAttribute(node, "relativeFrom") ? { relativeFrom: readOptionalAttribute(node, "relativeFrom") } : {},
+    ...align && extractText(align).trim() ? { align: extractText(align).trim() } : {}
+  };
+  if (posOffset) {
+    const offset = Number.parseInt(extractText(posOffset).trim(), 10);
+    if (Number.isFinite(offset)) {
+      position.offset = offset;
+    }
+  }
+  return Object.keys(position).length > 0 ? position : void 0;
+}
+function readAltText(node) {
+  if (!node) {
+    return void 0;
+  }
+  const description = node.attributes.descr?.trim();
+  if (description) {
+    return description;
+  }
+  const title = node.attributes.title?.trim();
+  if (title) {
+    return title;
+  }
+  const name = node.attributes.name?.trim();
+  return name || void 0;
+}
+function findFirstDescendant(node, local) {
+  for (const child of node.children) {
+    if (child.type !== "element") {
+      continue;
+    }
+    if (localName2(child.name) === local) {
+      return child;
+    }
+    const nested = findFirstDescendant(child, local);
+    if (nested) {
+      return nested;
+    }
+  }
+  return void 0;
+}
+function findDescendants(node, local) {
+  const results = [];
+  for (const child of node.children) {
+    if (child.type !== "element") {
+      continue;
+    }
+    if (localName2(child.name) === local) {
+      results.push(child);
+    }
+    results.push(...findDescendants(child, local));
+  }
+  return results;
+}
+function localName2(name) {
+  const separatorIndex = name.indexOf(":");
+  return separatorIndex >= 0 ? name.slice(separatorIndex + 1) : name;
+}
+function extractText(node) {
+  return node.children.map((child) => child.type === "text" ? child.text : extractText(child)).join("");
+}
+function readOptionalAttribute(node, name) {
+  return node.attributes[`wp:${name}`] ?? node.attributes[`w:${name}`] ?? node.attributes[name];
+}
+function readEmuAttribute(node, name) {
+  const value = node.attributes[name] ?? node.attributes[`wp:${name}`];
+  if (value === void 0) return void 0;
+  const parsed = Number.parseInt(value, 10);
+  return Number.isFinite(parsed) && parsed >= 0 ? parsed : void 0;
+}
+function readBooleanAttribute(node, name) {
+  const value = readOptionalAttribute(node, name);
+  if (value === void 0) {
+    return void 0;
+  }
+  return value !== "0" && value !== "false" && value !== "off";
+}
+function parseXml2(xml) {
+  const root = {
+    type: "element",
+    name: "__root__",
+    attributes: {},
+    children: []
+  };
+  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[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 });
+      }
+      cursor = end;
+      continue;
+    }
+    if (xml[cursor + 1] === "/") {
+      const end = xml.indexOf(">", cursor);
+      const current = stack.pop();
+      const name2 = xml.slice(cursor + 2, end).trim();
+      if (!current || localName2(current.name) !== localName2(name2)) {
+        throw new Error(`Malformed XML: unexpected closing tag </${name2}>.`);
+      }
+      cursor = end + 1;
+      continue;
+    }
+    const tagEnd = findTagEnd2(xml, cursor);
+    const tagBody = xml.slice(cursor + 1, tagEnd);
+    const selfClosing = /\/\s*$/.test(tagBody);
+    const { name, attributes } = parseTag2(tagBody.replace(/\/\s*$/, "").trim());
+    const element = {
+      type: "element",
+      name,
+      attributes,
+      children: []
+    };
+    stack[stack.length - 1]?.children.push(element);
+    if (!selfClosing) {
+      stack.push(element);
+    }
+    cursor = tagEnd + 1;
+  }
+  if (stack.length !== 1) {
+    throw new Error("Malformed XML: unclosed element.");
+  }
+  return root;
+}
+function parseTag2(tagBody) {
+  let cursor = 0;
+  while (cursor < tagBody.length && /\s/.test(tagBody[cursor] ?? "")) {
+    cursor += 1;
+  }
+  const nameStart = cursor;
+  while (cursor < tagBody.length && !/\s/.test(tagBody[cursor] ?? "")) {
+    cursor += 1;
+  }
+  const name = tagBody.slice(nameStart, cursor);
+  const attributes = {};
+  while (cursor < tagBody.length) {
+    while (cursor < tagBody.length && /\s/.test(tagBody[cursor] ?? "")) {
+      cursor += 1;
+    }
+    if (cursor >= tagBody.length) {
+      break;
+    }
+    const keyStart = cursor;
+    while (cursor < tagBody.length && !/[\s=]/.test(tagBody[cursor] ?? "")) {
+      cursor += 1;
+    }
+    const key = tagBody.slice(keyStart, cursor);
+    while (cursor < tagBody.length && /\s/.test(tagBody[cursor] ?? "")) {
+      cursor += 1;
+    }
+    if (tagBody[cursor] !== "=") {
+      attributes[key] = "";
+      continue;
+    }
+    cursor += 1;
+    while (cursor < tagBody.length && /\s/.test(tagBody[cursor] ?? "")) {
+      cursor += 1;
+    }
+    const quote = tagBody[cursor];
+    if (quote !== `"` && quote !== `'`) {
+      throw new Error(`Malformed XML attribute ${key}.`);
+    }
+    cursor += 1;
+    const valueStart = cursor;
+    while (cursor < tagBody.length && tagBody[cursor] !== quote) {
+      cursor += 1;
+    }
+    attributes[key] = decodeXmlEntities2(tagBody.slice(valueStart, cursor));
+    cursor += 1;
+  }
+  return { name, attributes };
+}
+function findTagEnd2(xml, start) {
+  let cursor = start + 1;
+  let quote = null;
+  while (cursor < xml.length) {
+    const current = xml[cursor];
+    if (quote) {
+      if (current === quote) {
+        quote = null;
+      }
+      cursor += 1;
+      continue;
+    }
+    if (current === `"` || current === `'`) {
+      quote = current;
+      cursor += 1;
+      continue;
+    }
+    if (current === ">") {
+      return cursor;
+    }
+    cursor += 1;
+  }
+  throw new Error("Malformed XML: missing >.");
+}
+function decodeXmlEntities2(value) {
+  return value.replace(/&(#x[0-9a-fA-F]+|#\d+|amp|lt|gt|quot|apos);/g, (match, entity) => {
+    switch (entity) {
+      case "amp":
+        return "&";
+      case "lt":
+        return "<";
+      case "gt":
+        return ">";
+      case "quot":
+        return `"`;
+      case "apos":
+        return "'";
+      default:
+        if (entity.startsWith("#x")) {
+          return String.fromCodePoint(Number.parseInt(entity.slice(2), 16));
+        }
+        if (entity.startsWith("#")) {
+          return String.fromCodePoint(Number.parseInt(entity.slice(1), 10));
+        }
+        return match;
+    }
+  });
+}
+
+// src/io/ooxml/parse-complex-content.ts
+var CHART_GRAPHIC_URI = "http://schemas.openxmlformats.org/drawingml/2006/chart";
+var CHART_GRAPHIC_URI_ALT = "http://schemas.microsoft.com/office/drawing/2007/8/2/chart";
+var SMARTART_GRAPHIC_URI = "http://schemas.microsoft.com/office/drawing/2007/8/2/diagram";
+var SMARTART_GRAPHIC_URI_ALT = "http://schemas.openxmlformats.org/drawingml/2006/diagram";
+function parseComplexContentXml(drawingXml, relationships, mediaParts = /* @__PURE__ */ new Map(), sourcePartPath = "/word/document.xml") {
+  const root = parseXml3(drawingXml);
+  const relationshipMap = new Map(relationships.map((r) => [r.id, r]));
+  const altContent = findFirstDescendant2(root, "AlternateContent");
+  if (altContent) {
+    return parseAlternateContent(altContent, drawingXml, relationshipMap, mediaParts, sourcePartPath);
+  }
+  const graphicData = findFirstDescendant2(root, "graphicData");
+  if (!graphicData) {
+    return null;
+  }
+  const uri = graphicData.attributes.uri ?? graphicData.attributes["uri"] ?? "";
+  if (isChartUri(uri)) {
+    return { type: "chart_preview", rawXml: drawingXml };
+  }
+  if (isSmartArtUri(uri)) {
+    return { type: "smartart_preview", rawXml: drawingXml };
+  }
+  return null;
+}
+function parseAlternateContent(altContent, fullDrawingXml, relationshipMap, mediaParts, sourcePartPath) {
+  const choice = findFirstChild(altContent, "Choice");
+  const fallback = findFirstChild(altContent, "Fallback");
+  const choiceGraphicData = choice ? findFirstDescendant2(choice, "graphicData") : null;
+  const choiceUri = choiceGraphicData?.attributes.uri ?? "";
+  let contentType = null;
+  if (isChartUri(choiceUri)) {
+    contentType = "chart_preview";
+  } else if (isSmartArtUri(choiceUri)) {
+    contentType = "smartart_preview";
+  } else {
+    const chartRef = choice ? findFirstDescendant2(choice, "chart") : null;
+    if (chartRef) {
+      contentType = "chart_preview";
+    }
+    const dmRef = choice ? findFirstDescendant2(choice, "relIds") : null;
+    if (dmRef) {
+      contentType = "smartart_preview";
+    }
+  }
+  if (!contentType) {
+    return null;
+  }
+  let previewMediaId;
+  if (fallback) {
+    const fallbackBlip = findFirstDescendant2(fallback, "blip");
+    if (fallbackBlip) {
+      const rId = fallbackBlip.attributes["r:embed"] ?? fallbackBlip.attributes.embed ?? fallbackBlip.attributes["r:link"];
+      if (rId) {
+        const rel = relationshipMap.get(rId);
+        if (rel && rel.type.endsWith("/image")) {
+          const packagePartName = normalizePartPath(
+            resolveRelationshipTarget(sourcePartPath, rel)
+          );
+          const mediaPart = mediaParts.get(packagePartName);
+          if (mediaPart) {
+            previewMediaId = `media:${packagePartName.slice(1)}`;
+          }
+        }
+      }
+    }
+  }
+  return {
+    type: contentType,
+    ...previewMediaId ? { previewMediaId } : {},
+    rawXml: fullDrawingXml
+  };
+}
+function isChartUri(uri) {
+  return uri === CHART_GRAPHIC_URI || uri === CHART_GRAPHIC_URI_ALT;
+}
+function isSmartArtUri(uri) {
+  return uri === SMARTART_GRAPHIC_URI || uri === SMARTART_GRAPHIC_URI_ALT || uri.includes("diagram") || uri.includes("dgm");
+}
+function findFirstChild(node, local) {
+  for (const child of node.children) {
+    if (child.type === "element" && localName3(child.name) === local) {
+      return child;
+    }
+  }
+  return void 0;
+}
+function findFirstDescendant2(node, local) {
+  for (const child of node.children) {
+    if (child.type !== "element") continue;
+    if (localName3(child.name) === local) return child;
+    const nested = findFirstDescendant2(child, local);
+    if (nested) return nested;
+  }
+  return void 0;
+}
+function localName3(name) {
+  const i = name.indexOf(":");
+  return i >= 0 ? name.slice(i + 1) : name;
+}
+function parseXml3(xml) {
+  const root = { type: "element", name: "__root__", attributes: {}, children: [] };
+  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[cursor] !== "<") {
+      const nextTag = xml.indexOf("<", cursor);
+      const end = nextTag >= 0 ? nextTag : xml.length;
+      const text = xml.slice(cursor, end);
+      if (text.length > 0) {
+        stack[stack.length - 1]?.children.push({ type: "text", text });
+      }
+      cursor = end;
+      continue;
+    }
+    if (xml[cursor + 1] === "/") {
+      const end = xml.indexOf(">", cursor);
+      stack.pop();
+      cursor = end + 1;
+      continue;
+    }
+    const tagEnd = findTagEnd3(xml, cursor);
+    const tagBody = xml.slice(cursor + 1, tagEnd);
+    const selfClosing = /\/\s*$/.test(tagBody);
+    const { name, attributes } = parseTag3(tagBody.replace(/\/\s*$/, "").trim());
+    const element = { type: "element", name, attributes, children: [] };
+    stack[stack.length - 1]?.children.push(element);
+    if (!selfClosing) stack.push(element);
+    cursor = tagEnd + 1;
+  }
+  return root;
+}
+function parseTag3(tagBody) {
+  let cursor = 0;
+  while (cursor < tagBody.length && /\s/.test(tagBody[cursor] ?? "")) cursor++;
+  const nameStart = cursor;
+  while (cursor < tagBody.length && !/\s/.test(tagBody[cursor] ?? "")) cursor++;
+  const name = tagBody.slice(nameStart, cursor);
+  const attributes = {};
+  while (cursor < tagBody.length) {
+    while (cursor < tagBody.length && /\s/.test(tagBody[cursor] ?? "")) cursor++;
+    if (cursor >= tagBody.length) break;
+    const keyStart = cursor;
+    while (cursor < tagBody.length && !/[\s=]/.test(tagBody[cursor] ?? "")) cursor++;
+    const key = tagBody.slice(keyStart, cursor);
+    while (cursor < tagBody.length && /\s/.test(tagBody[cursor] ?? "")) cursor++;
+    if (tagBody[cursor] !== "=") {
+      attributes[key] = "";
+      continue;
+    }
+    cursor++;
+    while (cursor < tagBody.length && /\s/.test(tagBody[cursor] ?? "")) cursor++;
+    const quote = tagBody[cursor];
+    if (quote !== `"` && quote !== `'`) break;
+    cursor++;
+    const valueStart = cursor;
+    while (cursor < tagBody.length && tagBody[cursor] !== quote) cursor++;
+    attributes[key] = tagBody.slice(valueStart, cursor);
+    cursor++;
+  }
+  return { name, attributes };
+}
+function findTagEnd3(xml, start) {
+  let cursor = start + 1;
+  let quote = null;
+  while (cursor < xml.length) {
+    const c = xml[cursor];
+    if (quote) {
+      if (c === quote) quote = null;
+      cursor++;
+      continue;
+    }
+    if (c === `"` || c === `'`) {
+      quote = c;
+      cursor++;
+      continue;
+    }
+    if (c === ">") return cursor;
+    cursor++;
+  }
+  return xml.length - 1;
+}
+
+// src/io/ooxml/parse-shapes.ts
+var WPS_SHAPE_GRAPHIC_URI = "http://schemas.microsoft.com/office/word/2010/wordprocessingShape";
+function parseShapeXml(drawingXml) {
+  const root = parseXml4(drawingXml);
+  const graphicData = findFirstDescendant3(root, "graphicData");
+  if (!graphicData) return null;
+  const uri = graphicData.attributes.uri ?? "";
+  if (uri !== WPS_SHAPE_GRAPHIC_URI) return null;
+  const wsp = findFirstDescendant3(root, "wsp");
+  if (!wsp) return null;
+  const spPr = findFirstChild2(wsp, "spPr");
+  const prstGeom = spPr ? findFirstDescendant3(spPr, "prstGeom") : null;
+  const prst = prstGeom?.attributes.prst ?? prstGeom?.attributes["prst"] ?? void 0;
+  const txbx = findFirstChild2(wsp, "txbx");
+  const txbxContent = txbx ? findFirstDescendant3(txbx, "txbxContent") : null;
+  const text = txbxContent ? extractAllText(txbxContent).trim() || void 0 : void 0;
+  if (prst && /^text/i.test(prst)) {
+    return {
+      type: "wordart",
+      text: text ?? "",
+      ...prst ? { geometry: prst } : {},
+      rawXml: drawingXml
+    };
+  }
+  const isTextBox = Boolean(txbxContent && (!prst || prst === "rect"));
+  const txbxContentXml = txbxContent ? extractRawXml(txbxContent, drawingXml) : void 0;
+  return {
+    type: "shape",
+    ...isTextBox ? { isTextBox: true } : {},
+    ...text ? { text } : {},
+    ...txbxContentXml ? { txbxContentXml } : {},
+    ...prst ? { geometry: prst } : {},
+    rawXml: drawingXml
+  };
+}
+function parseVmlXml(pictXml) {
+  const root = parseXml4(pictXml);
+  const vShape = findFirstDescendant3(root, "shape");
+  const vRect = findFirstDescendant3(root, "rect");
+  const vTextbox = findFirstDescendant3(root, "textbox");
+  const vmlNode = vShape ?? vRect ?? vTextbox;
+  if (!vmlNode) return null;
+  const shapeType = vShape?.attributes.type ?? vShape?.attributes["type"] ?? void 0;
+  let text;
+  const textboxNode = findFirstDescendant3(vmlNode, "textbox") ?? (localName4(vmlNode.name) === "textbox" ? vmlNode : null);
+  if (textboxNode) {
+    const txbxContent = findFirstDescendant3(textboxNode, "txbxContent");
+    if (txbxContent) {
+      text = extractAllText(txbxContent).trim() || void 0;
+    } else {
+      text = extractAllText(textboxNode).trim() || void 0;
+    }
+  }
+  return {
+    type: "vml_shape",
+    ...shapeType ? { shapeType } : {},
+    ...text ? { text } : {},
+    rawXml: pictXml
+  };
+}
+function extractRawXml(node, sourceXml) {
+  const tagName = node.name;
+  const openIdx = sourceXml.indexOf(`<${tagName}`);
+  if (openIdx < 0) return void 0;
+  const closeTag = `</${tagName}>`;
+  const closeIdx = sourceXml.indexOf(closeTag, openIdx);
+  if (closeIdx < 0) return void 0;
+  return sourceXml.slice(openIdx, closeIdx + closeTag.length);
+}
+function extractAllText(node) {
+  return node.children.map((child) => {
+    if (child.type === "text") return child.text;
+    if (child.type === "element" && localName4(child.name) === "t") {
+      return extractAllText(child);
+    }
+    return extractAllText(child);
+  }).join("");
+}
+function findFirstChild2(node, local) {
+  for (const child of node.children) {
+    if (child.type === "element" && localName4(child.name) === local) return child;
+  }
+  return void 0;
+}
+function findFirstDescendant3(node, local) {
+  for (const child of node.children) {
+    if (child.type !== "element") continue;
+    if (localName4(child.name) === local) return child;
+    const nested = findFirstDescendant3(child, local);
+    if (nested) return nested;
+  }
+  return void 0;
+}
+function localName4(name) {
+  const i = name.indexOf(":");
+  return i >= 0 ? name.slice(i + 1) : name;
+}
+function parseXml4(xml) {
+  const root = { type: "element", name: "__root__", attributes: {}, children: [] };
+  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[cursor] !== "<") {
+      const nextTag = xml.indexOf("<", cursor);
+      const end = nextTag >= 0 ? nextTag : xml.length;
+      const text = xml.slice(cursor, end);
+      if (text.length > 0) stack[stack.length - 1]?.children.push({ type: "text", text });
+      cursor = end;
+      continue;
+    }
+    if (xml[cursor + 1] === "/") {
+      const end = xml.indexOf(">", cursor);
+      stack.pop();
+      cursor = end + 1;
+      continue;
+    }
+    const tagEnd = findTagEnd4(xml, cursor);
+    const tagBody = xml.slice(cursor + 1, tagEnd);
+    const selfClosing = /\/\s*$/.test(tagBody);
+    const { name, attributes } = parseTag4(tagBody.replace(/\/\s*$/, "").trim());
+    const element = { type: "element", name, attributes, children: [] };
+    stack[stack.length - 1]?.children.push(element);
+    if (!selfClosing) stack.push(element);
+    cursor = tagEnd + 1;
+  }
+  return root;
+}
+function parseTag4(tagBody) {
+  let cursor = 0;
+  while (cursor < tagBody.length && /\s/.test(tagBody[cursor] ?? "")) cursor++;
+  const nameStart = cursor;
+  while (cursor < tagBody.length && !/\s/.test(tagBody[cursor] ?? "")) cursor++;
+  const name = tagBody.slice(nameStart, cursor);
+  const attributes = {};
+  while (cursor < tagBody.length) {
+    while (cursor < tagBody.length && /\s/.test(tagBody[cursor] ?? "")) cursor++;
+    if (cursor >= tagBody.length) break;
+    const keyStart = cursor;
+    while (cursor < tagBody.length && !/[\s=]/.test(tagBody[cursor] ?? "")) cursor++;
+    const key = tagBody.slice(keyStart, cursor);
+    while (cursor < tagBody.length && /\s/.test(tagBody[cursor] ?? "")) cursor++;
+    if (tagBody[cursor] !== "=") {
+      attributes[key] = "";
+      continue;
+    }
+    cursor++;
+    while (cursor < tagBody.length && /\s/.test(tagBody[cursor] ?? "")) cursor++;
+    const quote = tagBody[cursor];
+    if (quote !== `"` && quote !== `'`) break;
+    cursor++;
+    const valueStart = cursor;
+    while (cursor < tagBody.length && tagBody[cursor] !== quote) cursor++;
+    attributes[key] = tagBody.slice(valueStart, cursor);
+    cursor++;
+  }
+  return { name, attributes };
+}
+function findTagEnd4(xml, start) {
+  let cursor = start + 1;
+  let quote = null;
+  while (cursor < xml.length) {
+    const c = xml[cursor];
+    if (quote) {
+      if (c === quote) quote = null;
+      cursor++;
+      continue;
+    }
+    if (c === `"` || c === `'`) {
+      quote = c;
+      cursor++;
+      continue;
+    }
+    if (c === ">") return cursor;
+    cursor++;
+  }
+  return xml.length - 1;
+}
+
+// src/io/ooxml/highlight-colors.ts
+var HIGHLIGHT_COLOR_MAP = {
+  black: "000000",
+  blue: "0000FF",
+  cyan: "00FFFF",
+  darkBlue: "000080",
+  darkCyan: "008080",
+  darkGray: "808080",
+  darkGreen: "008000",
+  darkMagenta: "800080",
+  darkRed: "8B0000",
+  darkYellow: "808000",
+  green: "00FF00",
+  lightGray: "C0C0C0",
+  magenta: "FF00FF",
+  red: "FF0000",
+  white: "FFFFFF",
+  yellow: "FFFF00"
+};
+function resolveHighlightColor(value) {
+  if (!value || value === "none") {
+    return void 0;
+  }
+  const normalizedValue = value;
+  const color = HIGHLIGHT_COLOR_MAP[normalizedValue];
+  if (!color) {
+    return void 0;
+  }
+  return {
+    color,
+    val: normalizedValue
+  };
+}
+
+// src/io/ooxml/parse-main-document.ts
+var HYPERLINK_RELATIONSHIP_TYPE = "http://schemas.openxmlformats.org/officeDocument/2006/relationships/hyperlink";
+function parseMainDocumentXml(xml, relationships = [], mediaParts = /* @__PURE__ */ new Map(), sourcePartPath = "/word/document.xml") {
+  const root = parseXml5(xml);
+  const documentElement = findChildElement2(root, "document");
+  const bodyElement = findChildElement2(documentElement, "body");
+  const relationshipMap = new Map(relationships.map((relationship) => [relationship.id, relationship]));
+  const allBlocks = bodyElement.children.filter((node) => node.type === "element").map((node) => parseBodyChild(node, xml, relationshipMap, relationships, mediaParts, sourcePartPath));
+  let finalSectionProperties;
+  const blocks = [];
+  for (let i = 0; i < allBlocks.length; i++) {
+    const block = allBlocks[i];
+    if (block.type === "section_break" && i === allBlocks.length - 1) {
+      finalSectionProperties = block.sectionProperties;
+    } else {
+      blocks.push(block);
+    }
+  }
+  return { blocks, finalSectionProperties };
+}
+function parseBodyChild(node, sourceXml, relationshipMap, relationships, mediaParts, sourcePartPath) {
+  const nodeType = localName5(node.name);
+  if (nodeType === "tbl") {
+    const rawTableXml = sourceXml.slice(node.start, node.end);
+    if (tableRequiresOpaquePreservation(rawTableXml)) {
+      return {
+        type: "opaque_block",
+        rawXml: rawTableXml
+      };
+    }
+    try {
+      return parseTableElement(node, sourceXml, relationshipMap, relationships, mediaParts, sourcePartPath);
+    } catch {
+      return {
+        type: "opaque_block",
+        rawXml: rawTableXml
+      };
+    }
+  }
+  if (nodeType === "sdt") {
+    return parseSdtElement(node, sourceXml, relationshipMap, relationships, mediaParts, sourcePartPath);
+  }
+  if (nodeType === "customXml") {
+    return parseCustomXmlElement(node, sourceXml, relationshipMap, relationships, mediaParts, sourcePartPath);
+  }
+  if (nodeType === "altChunk") {
+    return parseAltChunkElement(node, sourceXml);
+  }
+  if (nodeType === "sectPr") {
+    return parseSectionBreakElement(node, sourceXml);
+  }
+  if (nodeType !== "p") {
+    return {
+      type: "opaque_block",
+      rawXml: sourceXml.slice(node.start, node.end)
+    };
+  }
+  let styleId;
+  let numbering;
+  let alignment;
+  let spacing;
+  let contextualSpacing;
+  let indentation;
+  let tabStops;
+  let keepNext;
+  let keepLines;
+  let outlineLevel;
+  let pageBreakBefore;
+  let widowControl;
+  let borders;
+  let shading;
+  let bidi;
+  let suppressLineNumbers;
+  let cnfStyle;
+  let sectionProperties;
+  let sectionPropertiesXml;
+  let paragraphSupported = true;
+  const children = [];
+  let activeComplexField = null;
+  for (const child of node.children) {
+    if (child.type !== "element") {
+      continue;
+    }
+    switch (localName5(child.name)) {
+      case "pPr":
+        styleId = readParagraphStyleId(child);
+        numbering = readParagraphNumbering(child);
+        alignment = readParagraphAlignment(child);
+        spacing = readParagraphSpacing(child);
+        contextualSpacing = readOptionalOnOffParagraphProperty(child, "contextualSpacing");
+        indentation = readParagraphIndentation(child);
+        tabStops = readParagraphTabStops(child);
+        keepNext = readOnOffParagraphProperty(child, "keepNext");
+        keepLines = readOnOffParagraphProperty(child, "keepLines");
+        outlineLevel = readParagraphOutlineLevel(child);
+        pageBreakBefore = readOnOffParagraphProperty(child, "pageBreakBefore");
+        widowControl = readOnOffParagraphProperty(child, "widowControl");
+        borders = readParagraphBorders(child);
+        shading = readParagraphShading(child);
+        bidi = readOnOffParagraphProperty(child, "bidi");
+        suppressLineNumbers = readOnOffParagraphProperty(child, "suppressLineNumbers");
+        cnfStyle = readParagraphCnfStyle(child);
+        sectionProperties = readSectionPropertiesFromPPr(child);
+        sectionPropertiesXml = readSectionPropertiesXmlFromPPr(child, sourceXml);
+        paragraphSupported = paragraphSupported && supportsParagraphProperties(child);
+        break;
+      case "r":
+        activeComplexField = appendParagraphRunNodes(
+          child,
+          children,
+          activeComplexField,
+          sourceXml,
+          relationships,
+          mediaParts,
+          sourcePartPath
+        );
+        break;
+      case "hyperlink": {
+        flushActiveComplexField(children, () => {
+          activeComplexField = null;
+        }, activeComplexField);
+        const hyperlink = parseHyperlink(child, sourceXml, relationshipMap);
+        children.push(hyperlink);
+        break;
+      }
+      case "ins":
+      case "del": {
+        flushActiveComplexField(children, () => {
+          activeComplexField = null;
+        }, activeComplexField);
+        children.push(...parseRevisionContainer(child, sourceXml, relationshipMap));
+        break;
+      }
+      case "commentRangeStart":
+      case "commentRangeEnd":
+        break;
+      case "bookmarkStart": {
+        const bkId = child.attributes["w:id"] ?? child.attributes.id ?? "";
+        const bkName = child.attributes["w:name"] ?? child.attributes.name ?? "";
+        if (bkId) {
+          const bookmarkNode = {
+            type: "bookmark_start",
+            bookmarkId: bkId,
+            name: bkName,
+            rawXml: sourceXml.slice(child.start, child.end)
+          };
+          flushActiveComplexField(children, () => {
+            activeComplexField = null;
+          }, activeComplexField);
+          children.push(bookmarkNode);
+        } else {
+          flushActiveComplexField(children, () => {
+            activeComplexField = null;
+          }, activeComplexField);
+          children.push({ type: "opaque_inline", rawXml: sourceXml.slice(child.start, child.end) });
+        }
+        break;
+      }
+      case "bookmarkEnd": {
+        const bkEndId = child.attributes["w:id"] ?? child.attributes.id ?? "";
+        if (bkEndId) {
+          const bookmarkNode = {
+            type: "bookmark_end",
+            bookmarkId: bkEndId,
+            rawXml: sourceXml.slice(child.start, child.end)
+          };
+          flushActiveComplexField(children, () => {
+            activeComplexField = null;
+          }, activeComplexField);
+          children.push(bookmarkNode);
+        } else {
+          flushActiveComplexField(children, () => {
+            activeComplexField = null;
+          }, activeComplexField);
+          children.push({ type: "opaque_inline", rawXml: sourceXml.slice(child.start, child.end) });
+        }
+        break;
+      }
+      case "fldSimple": {
+        flushActiveComplexField(children, () => {
+          activeComplexField = null;
+        }, activeComplexField);
+        const fieldInstr = child.attributes["w:instr"] ?? child.attributes.instr ?? "";
+        const fieldContentXml = child.children.filter((c) => c.type === "element").map((c) => sourceXml.slice(c.start, c.end)).join("");
+        children.push({
+          type: "field",
+          fieldType: "simple",
+          instruction: fieldInstr,
+          contentXml: fieldContentXml,
+          rawXml: sourceXml.slice(child.start, child.end)
+        });
+        break;
+      }
+      case "proofErr":
+        flushActiveComplexField(children, () => {
+          activeComplexField = null;
+        }, activeComplexField);
+        children.push({
+          type: "opaque_inline",
+          rawXml: sourceXml.slice(child.start, child.end)
+        });
+        break;
+      case "permStart":
+        flushActiveComplexField(children, () => {
+          activeComplexField = null;
+        }, activeComplexField);
+        children.push(parsePermStartNode(child, sourceXml));
+        break;
+      case "permEnd":
+        flushActiveComplexField(children, () => {
+          activeComplexField = null;
+        }, activeComplexField);
+        children.push(parsePermEndNode(child, sourceXml));
+        break;
+      case "footnoteReference": {
+        flushActiveComplexField(children, () => {
+          activeComplexField = null;
+        }, activeComplexField);
+        const noteId = child.attributes["w:id"] ?? child.attributes.id ?? "";
+        if (noteId) {
+          children.push({
+            type: "footnote_ref",
+            noteId,
+            noteKind: "footnote"
+          });
+        }
+        break;
+      }
+      case "endnoteReference": {
+        flushActiveComplexField(children, () => {
+          activeComplexField = null;
+        }, activeComplexField);
+        const noteId = child.attributes["w:id"] ?? child.attributes.id ?? "";
+        if (noteId) {
+          children.push({
+            type: "footnote_ref",
+            noteId,
+            noteKind: "endnote"
+          });
+        }
+        break;
+      }
+      default:
+        flushActiveComplexField(children, () => {
+          activeComplexField = null;
+        }, activeComplexField);
+        children.push({
+          type: "opaque_inline",
+          rawXml: sourceXml.slice(child.start, child.end)
+        });
+        break;
+    }
+  }
+  flushActiveComplexField(children, () => {
+    activeComplexField = null;
+  }, activeComplexField);
+  if (!paragraphSupported) {
+    return {
+      type: "opaque_block",
+      rawXml: sourceXml.slice(node.start, node.end)
+    };
+  }
+  return {
+    type: "paragraph",
+    styleId,
+    ...numbering ? { numbering } : {},
+    ...alignment ? { alignment } : {},
+    ...spacing ? { spacing } : {},
+    ...contextualSpacing !== void 0 ? { contextualSpacing } : {},
+    ...indentation ? { indentation } : {},
+    ...tabStops && tabStops.length > 0 ? { tabStops } : {},
+    ...keepNext ? { keepNext } : {},
+    ...keepLines ? { keepLines } : {},
+    ...outlineLevel !== void 0 ? { outlineLevel } : {},
+    ...pageBreakBefore ? { pageBreakBefore } : {},
+    ...widowControl ? { widowControl } : {},
+    ...borders ? { borders } : {},
+    ...shading ? { shading } : {},
+    ...bidi ? { bidi } : {},
+    ...suppressLineNumbers ? { suppressLineNumbers } : {},
+    ...cnfStyle ? { cnfStyle } : {},
+    ...sectionProperties ? { sectionProperties } : {},
+    ...sectionPropertiesXml ? { sectionPropertiesXml } : {},
+    children,
+    rawXml: sourceXml.slice(node.start, node.end)
+  };
+}
+function appendParagraphRunNodes(node, children, activeComplexField, sourceXml, relationships, mediaParts, sourcePartPath) {
+  const hasFieldMarkers = node.children.some(
+    (child) => child.type === "element" && (localName5(child.name) === "fldChar" || localName5(child.name) === "instrText")
+  );
+  if (activeComplexField?.mode === "result" && !hasFieldMarkers) {
+    const run = parseRunContentOnly(node, sourceXml);
+    if (run.supported && run.nodes.every(
+      (child) => child.type === "text" || child.type === "hard_break" || child.type === "tab"
+    )) {
+      activeComplexField.children.push(...run.nodes);
+      return activeComplexField;
+    }
+  }
+  if (!hasFieldMarkers) {
+    children.push(...parseRun(node, sourceXml, relationships, mediaParts, sourcePartPath));
+    return activeComplexField;
+  }
+  for (const child of node.children) {
+    if (child.type !== "element") {
+      continue;
+    }
+    const name = localName5(child.name);
+    if (name === "fldChar") {
+      const fldType = child.attributes["w:fldCharType"] ?? child.attributes.fldCharType;
+      if (fldType === "begin") {
+        activeComplexField = { instruction: "", children: [], mode: "instruction" };
+      } else if (fldType === "separate" && activeComplexField) {
+        activeComplexField.mode = "result";
+      } else if (fldType === "end" && activeComplexField) {
+        flushActiveComplexField(children, () => {
+          activeComplexField = null;
+        }, activeComplexField);
+      }
+      continue;
+    }
+    if (name === "instrText") {
+      const instruction = child.children.filter((entry) => entry.type === "text").map((entry) => entry.text).join("");
+      if (activeComplexField) {
+        activeComplexField.instruction += instruction;
+      } else if (instruction.trim().length > 0) {
+        children.push({
+          type: "field",
+          fieldType: "complex",
+          instruction,
+          children: [],
+          rawXml: sourceXml.slice(node.start, node.end)
+        });
+      }
+      continue;
+    }
+  }
+  return activeComplexField;
+}
+function flushActiveComplexField(children, reset, activeComplexField) {
+  if (!activeComplexField || activeComplexField.instruction.trim().length === 0) {
+    return;
+  }
+  children.push({
+    type: "field",
+    fieldType: "complex",
+    instruction: activeComplexField.instruction,
+    children: activeComplexField.children,
+    rawXml: ""
+  });
+  reset();
+}
+function parseTableElement(node, sourceXml, relationshipMap, relationships, mediaParts, sourcePartPath) {
+  let styleId;
+  let tblLook;
+  let propertiesXml;
+  let gridColumns = [];
+  const rows = [];
+  for (const child of node.children) {
+    if (child.type !== "element") continue;
+    switch (localName5(child.name)) {
+      case "tblPr": {
+        propertiesXml = sourceXml.slice(child.start, child.end);
+        styleId = readTableStyleId(child);
+        tblLook = readTableLook(child);
+        break;
+      }
+      case "tblGrid": {
+        gridColumns = readTableGridColumns(child);
+        break;
+      }
+      case "tr": {
+        rows.push(parseTableRowElement(child, sourceXml, relationshipMap, relationships, mediaParts, sourcePartPath));
+        break;
+      }
+    }
+  }
+  return {
+    type: "table",
+    ...styleId ? { styleId } : {},
+    ...tblLook ? { tblLook } : {},
+    ...propertiesXml ? { propertiesXml } : {},
+    gridColumns,
+    rows,
+    rawXml: sourceXml.slice(node.start, node.end)
+  };
+}
+function parseTableRowElement(node, sourceXml, relationshipMap, relationships, mediaParts, sourcePartPath) {
+  let propertiesXml;
+  let gridBefore;
+  let widthBefore;
+  let gridAfter;
+  let widthAfter;
+  const cells = [];
+  for (const child of node.children) {
+    if (child.type !== "element") continue;
+    switch (localName5(child.name)) {
+      case "trPr":
+        propertiesXml = sourceXml.slice(child.start, child.end);
+        gridBefore = readTableRowGridPosition(child, "gridBefore");
+        widthBefore = readTableRowWidth(child, "wBefore");
+        gridAfter = readTableRowGridPosition(child, "gridAfter");
+        widthAfter = readTableRowWidth(child, "wAfter");
+        break;
+      case "tc":
+        cells.push(parseTableCellElement(child, sourceXml, relationshipMap, relationships, mediaParts, sourcePartPath));
+        break;
+    }
+  }
+  return {
+    type: "table_row",
+    ...propertiesXml ? { propertiesXml } : {},
+    ...gridBefore !== void 0 ? { gridBefore } : {},
+    ...widthBefore ? { widthBefore } : {},
+    ...gridAfter !== void 0 ? { gridAfter } : {},
+    ...widthAfter ? { widthAfter } : {},
+    cells,
+    rawXml: sourceXml.slice(node.start, node.end)
+  };
+}
+function parseTableCellElement(node, sourceXml, relationshipMap, relationships, mediaParts, sourcePartPath) {
+  let propertiesXml;
+  let gridSpan;
+  let verticalMerge;
+  const children = [];
+  for (const child of node.children) {
+    if (child.type !== "element") continue;
+    switch (localName5(child.name)) {
+      case "tcPr": {
+        propertiesXml = sourceXml.slice(child.start, child.end);
+        gridSpan = readCellGridSpan(child);
+        verticalMerge = readCellVerticalMerge(child);
+        break;
+      }
+      default: {
+        children.push(parseBodyChild(child, sourceXml, relationshipMap, relationships, mediaParts, sourcePartPath));
+        break;
+      }
+    }
+  }
+  return {
+    type: "table_cell",
+    ...propertiesXml ? { propertiesXml } : {},
+    ...gridSpan ? { gridSpan } : {},
+    ...verticalMerge ? { verticalMerge } : {},
+    children,
+    rawXml: sourceXml.slice(node.start, node.end)
+  };
+}
+function parseSdtElement(node, sourceXml, relationshipMap, relationships, mediaParts, sourcePartPath) {
+  const propertiesNode = node.children.find(
+    (child) => child.type === "element" && localName5(child.name) === "sdtPr"
+  );
+  const contentNode = node.children.find(
+    (child) => child.type === "element" && localName5(child.name) === "sdtContent"
+  );
+  if (!contentNode) {
+    return {
+      type: "opaque_block",
+      rawXml: sourceXml.slice(node.start, node.end)
+    };
+  }
+  const children = contentNode.children.filter((child) => child.type === "element").map((child) => parseBodyChild(child, sourceXml, relationshipMap, relationships, mediaParts, sourcePartPath));
+  return {
+    type: "sdt",
+    properties: readSdtProperties(propertiesNode, sourceXml),
+    children,
+    rawXml: sourceXml.slice(node.start, node.end)
+  };
+}
+function parseCustomXmlElement(node, sourceXml, relationshipMap, relationships, mediaParts, sourcePartPath) {
+  const uri = readOptionalAttribute2(node, "uri");
+  const element = readOptionalAttribute2(node, "element");
+  if (!uri && !element) {
+    return {
+      type: "opaque_block",
+      rawXml: sourceXml.slice(node.start, node.end)
+    };
+  }
+  const children = node.children.filter(
+    (child) => child.type === "element" && localName5(child.name) !== "customXmlPr"
+  ).map((child) => parseBodyChild(child, sourceXml, relationshipMap, relationships, mediaParts, sourcePartPath));
+  return {
+    type: "custom_xml",
+    ...uri ? { uri } : {},
+    ...element ? { element } : {},
+    children,
+    rawXml: sourceXml.slice(node.start, node.end)
+  };
+}
+function parseAltChunkElement(node, sourceXml) {
+  const relationshipId = readOptionalAttribute2(node, "id");
+  if (!relationshipId) {
+    return {
+      type: "opaque_block",
+      rawXml: sourceXml.slice(node.start, node.end)
+    };
+  }
+  return {
+    type: "alt_chunk",
+    relationshipId,
+    rawXml: sourceXml.slice(node.start, node.end)
+  };
+}
+function readSdtProperties(node, sourceXml) {
+  if (!node) {
+    return {};
+  }
+  const properties = {
+    propertiesXml: sourceXml.slice(node.start, node.end)
+  };
+  for (const child of node.children) {
+    if (child.type !== "element") {
+      continue;
+    }
+    const name = localName5(child.name);
+    if (name === "alias") {
+      properties.alias = readOptionalAttribute2(child, "val");
+      continue;
+    }
+    if (name === "tag") {
+      properties.tag = readOptionalAttribute2(child, "val");
+      continue;
+    }
+    if (name === "lock") {
+      properties.lock = readOptionalAttribute2(child, "val");
+      continue;
+    }
+    if (name === "showingPlcHdr") {
+      const val = readOptionalAttribute2(child, "val");
+      properties.showingPlcHdr = val !== "false" && val !== "0";
+      continue;
+    }
+    if (name === "checkbox") {
+      properties.sdtType = "checkbox";
+      const checkedNode = findFirstDescendant4(child, "checked");
+      const checkedVal = checkedNode ? readOptionalAttribute2(checkedNode, "val") ?? "0" : "0";
+      const checkedCharNode = findFirstDescendant4(child, "checkedState");
+      const uncheckedCharNode = findFirstDescendant4(child, "uncheckedState");
+      properties.checkbox = {
+        checked: checkedVal === "1" || checkedVal === "true",
+        ...checkedCharNode ? { checkedChar: readOptionalAttribute2(checkedCharNode, "val") } : {},
+        ...uncheckedCharNode ? { uncheckedChar: readOptionalAttribute2(uncheckedCharNode, "val") } : {}
+      };
+      continue;
+    }
+    if (name === "date") {
+      properties.sdtType = "date";
+      const fullDate = readOptionalAttribute2(child, "fullDate");
+      const dateFormatNode = findFirstChild3(child, "dateFormat");
+      const lidNode = findFirstChild3(child, "lid");
+      properties.datePicker = {
+        ...fullDate ? { fullDate } : {},
+        ...dateFormatNode ? { dateFormat: readOptionalAttribute2(dateFormatNode, "val") } : {},
+        ...lidNode ? { lid: readOptionalAttribute2(lidNode, "val") } : {}
+      };
+      continue;
+    }
+    if (name === "dropDownList") {
+      properties.sdtType = "dropDownList";
+      properties.dropdownList = readSdtListItems(child);
+      continue;
+    }
+    if (name === "comboBox") {
+      properties.sdtType = "comboBox";
+      properties.comboBox = readSdtListItems(child);
+      continue;
+    }
+    if (name === "text") {
+      properties.sdtType = "plainText";
+      continue;
+    }
+    if (name === "richText") {
+      properties.sdtType = "richText";
+      continue;
+    }
+    if (!properties.sdtType && name !== "id" && name !== "placeholder" && name !== "showingPlcHdr" && name !== "rPr") {
+      properties.sdtType = name;
+    }
+  }
+  return properties;
+}
+function readSdtListItems(node) {
+  const items = [];
+  for (const child of node.children) {
+    if (child.type !== "element" || localName5(child.name) !== "listItem") continue;
+    const value = readOptionalAttribute2(child, "value") ?? "";
+    const displayText = readOptionalAttribute2(child, "displayText");
+    items.push({ value, ...displayText ? { displayText } : {} });
+  }
+  return items;
+}
+function findFirstChild3(node, local) {
+  for (const child of node.children) {
+    if (child.type === "element" && localName5(child.name) === local) return child;
+  }
+  return void 0;
+}
+function findFirstDescendant4(node, local) {
+  for (const child of node.children) {
+    if (child.type !== "element") continue;
+    if (localName5(child.name) === local) return child;
+    const nested = findFirstDescendant4(child, local);
+    if (nested) return nested;
+  }
+  return void 0;
+}
+function readTableStyleId(node) {
+  for (const child of node.children) {
+    if (child.type !== "element" || localName5(child.name) !== "tblStyle") continue;
+    const styleId = child.attributes["w:val"] ?? child.attributes.val;
+    if (styleId) return styleId;
+  }
+  return void 0;
+}
+function readTableLook(node) {
+  const tblLookNode = node.children.find(
+    (child) => child.type === "element" && localName5(child.name) === "tblLook"
+  );
+  if (!tblLookNode) {
+    return void 0;
+  }
+  const tableLook = {};
+  const val = tblLookNode.attributes["w:val"] ?? tblLookNode.attributes.val;
+  if (val) {
+    tableLook.val = val;
+  }
+  for (const [attribute, key] of [
+    ["w:firstRow", "firstRow"],
+    ["w:lastRow", "lastRow"],
+    ["w:firstColumn", "firstColumn"],
+    ["w:lastColumn", "lastColumn"],
+    ["w:noHBand", "noHBand"],
+    ["w:noVBand", "noVBand"]
+  ]) {
+    const fallback = attribute.replace("w:", "");
+    const raw = tblLookNode.attributes[attribute] ?? tblLookNode.attributes[fallback];
+    if (raw !== void 0) {
+      tableLook[key] = raw !== "0" && raw !== "false" && raw !== "off";
+    }
+  }
+  return Object.keys(tableLook).length > 0 ? tableLook : void 0;
+}
+function readTableGridColumns(node) {
+  return node.children.filter((child) => child.type === "element" && localName5(child.name) === "gridCol").map((child) => {
+    const raw = child.attributes["w:w"] ?? child.attributes.w ?? "0";
+    const value = Number.parseInt(raw, 10);
+    return Number.isFinite(value) && value > 0 ? value : 0;
+  });
+}
+function tableRequiresOpaquePreservation(rawXml) {
+  if (/<w:(ins|del|rPrChange|pPrChange|tblPrChange|trPrChange|tcPrChange|sectPrChange|cellIns|cellDel|cellMerge|smartTag|tblCellSpacing)\b/.test(rawXml)) {
+    return true;
+  }
+  const simpleInstructions = [...rawXml.matchAll(/\bw:instr="([^"]*)"/g)].map((match) => match[1] ?? "");
+  const complexInstructions = extractComplexFieldInstructions(rawXml);
+  for (const instruction of [...simpleInstructions, ...complexInstructions]) {
+    const classification = classifyFieldInstruction(instruction);
+    if (!isSafeMainStoryTableFieldFamily(classification.family)) {
+      return true;
+    }
+  }
+  return false;
+}
+function isSafeMainStoryTableFieldFamily(family) {
+  return family === "REF" || family === "PAGEREF" || family === "NOTEREF" || family === "TOC" || family === "PAGE" || family === "NUMPAGES";
+}
+function extractComplexFieldInstructions(rawXml) {
+  const tokenPattern = /<(?:\w+:)?fldChar\b[^>]*?(?:\w+:)?fldCharType="(begin|separate|end)"[^>]*?(?:\/>|>[\s\S]*?<\/(?:\w+:)?fldChar>)|<(?:\w+:)?instrText\b[^>]*>([\s\S]*?)<\/(?:\w+:)?instrText>/gu;
+  const instructions = [];
+  let activeInstruction = "";
+  let capturingInstruction = false;
+  for (const match of rawXml.matchAll(tokenPattern)) {
+    const fldCharType = match[1];
+    const instrText = match[2];
+    if (fldCharType === "begin") {
+      activeInstruction = "";
+      capturingInstruction = true;
+      continue;
+    }
+    if (fldCharType === "separate" || fldCharType === "end") {
+      if (capturingInstruction && activeInstruction.trim().length > 0) {
+        instructions.push(activeInstruction);
+      }
+      activeInstruction = "";
+      capturingInstruction = false;
+      continue;
+    }
+    if (capturingInstruction && instrText !== void 0) {
+      activeInstruction += decodeXmlEntities3(instrText);
+    }
+  }
+  return instructions;
+}
+function readTableRowGridPosition(node, local) {
+  const positionNode = node.children.find(
+    (child) => child.type === "element" && localName5(child.name) === local
+  );
+  if (!positionNode) return void 0;
+  const raw = positionNode.attributes["w:val"] ?? positionNode.attributes.val;
+  const value = Number.parseInt(raw ?? "", 10);
+  return Number.isFinite(value) && value > 0 ? value : 0;
+}
+function readTableRowWidth(node, local) {
+  const widthNode = node.children.find(
+    (child) => child.type === "element" && localName5(child.name) === local
+  );
+  if (!widthNode) return void 0;
+  const rawValue = widthNode.attributes["w:w"] ?? widthNode.attributes.w;
+  const value = Number.parseInt(rawValue ?? "", 10);
+  if (!Number.isFinite(value)) {
+    return void 0;
+  }
+  const rawType = (widthNode.attributes["w:type"] ?? widthNode.attributes.type ?? "dxa").toLowerCase();
+  const type = rawType === "auto" ? "auto" : rawType === "pct" ? "pct" : rawType === "nil" ? "nil" : "dxa";
+  return { value, type };
+}
+function readCellGridSpan(node) {
+  const gridSpanNode = node.children.find(
+    (child) => child.type === "element" && localName5(child.name) === "gridSpan"
+  );
+  if (!gridSpanNode) return void 0;
+  const raw = gridSpanNode.attributes["w:val"] ?? gridSpanNode.attributes.val;
+  const value = Number.parseInt(raw ?? "0", 10);
+  return Number.isFinite(value) && value > 1 ? value : void 0;
+}
+function readCellVerticalMerge(node) {
+  const vMergeNode = node.children.find(
+    (child) => child.type === "element" && localName5(child.name) === "vMerge"
+  );
+  if (!vMergeNode) return void 0;
+  const raw = (vMergeNode.attributes["w:val"] ?? vMergeNode.attributes.val ?? "continue").toLowerCase();
+  return raw === "restart" ? "restart" : "continue";
+}
+function readParagraphAlignment(node) {
+  const jcNode = node.children.find(
+    (child) => child.type === "element" && localName5(child.name) === "jc"
+  );
+  if (!jcNode) return void 0;
+  const val = (jcNode.attributes["w:val"] ?? jcNode.attributes.val ?? "").toLowerCase();
+  if (val === "left" || val === "center" || val === "right" || val === "both" || val === "distribute") {
+    return val;
+  }
+  return void 0;
+}
+function readParagraphSpacing(node) {
+  const spacingNode = node.children.find(
+    (child) => child.type === "element" && localName5(child.name) === "spacing"
+  );
+  if (!spacingNode) return void 0;
+  const spacing = {};
+  const before = spacingNode.attributes["w:before"] ?? spacingNode.attributes.before;
+  const after = spacingNode.attributes["w:after"] ?? spacingNode.attributes.after;
+  const line = spacingNode.attributes["w:line"] ?? spacingNode.attributes.line;
+  const lineRule = spacingNode.attributes["w:lineRule"] ?? spacingNode.attributes.lineRule;
+  if (before !== void 0) {
+    const v = Number.parseInt(before, 10);
+    if (Number.isFinite(v)) spacing.before = v;
+  }
+  if (after !== void 0) {
+    const v = Number.parseInt(after, 10);
+    if (Number.isFinite(v)) spacing.after = v;
+  }
+  if (line !== void 0) {
+    const v = Number.parseInt(line, 10);
+    if (Number.isFinite(v)) spacing.line = v;
+  }
+  if (lineRule !== void 0) {
+    const lr = lineRule.toLowerCase();
+    if (lr === "auto" || lr === "exact") {
+      spacing.lineRule = lr;
+    } else if (lr === "atleast") {
+      spacing.lineRule = "atLeast";
+    }
+  }
+  if (spacing.before === void 0 && spacing.after === void 0 && spacing.line === void 0 && spacing.lineRule === void 0) {
+    return void 0;
+  }
+  return spacing;
+}
+function readParagraphIndentation(node) {
+  const indNode = node.children.find(
+    (child) => child.type === "element" && localName5(child.name) === "ind"
+  );
+  if (!indNode) return void 0;
+  const indentation = {};
+  const left = indNode.attributes["w:left"] ?? indNode.attributes.left;
+  const right = indNode.attributes["w:right"] ?? indNode.attributes.right;
+  const firstLine = indNode.attributes["w:firstLine"] ?? indNode.attributes.firstLine;
+  const hanging = indNode.attributes["w:hanging"] ?? indNode.attributes.hanging;
+  if (left !== void 0) {
+    const v = Number.parseInt(left, 10);
+    if (Number.isFinite(v)) indentation.left = v;
+  }
+  if (right !== void 0) {
+    const v = Number.parseInt(right, 10);
+    if (Number.isFinite(v)) indentation.right = v;
+  }
+  if (firstLine !== void 0) {
+    const v = Number.parseInt(firstLine, 10);
+    if (Number.isFinite(v)) indentation.firstLine = v;
+  }
+  if (hanging !== void 0) {
+    const v = Number.parseInt(hanging, 10);
+    if (Number.isFinite(v)) indentation.hanging = v;
+  }
+  if (indentation.left === void 0 && indentation.right === void 0 && indentation.firstLine === void 0 && indentation.hanging === void 0) {
+    return void 0;
+  }
+  return indentation;
+}
+function readParagraphTabStops(node) {
+  const tabsNode = node.children.find(
+    (child) => child.type === "element" && localName5(child.name) === "tabs"
+  );
+  if (!tabsNode) return void 0;
+  const tabStops = [];
+  for (const child of tabsNode.children) {
+    if (child.type !== "element" || localName5(child.name) !== "tab") continue;
+    const pos = child.attributes["w:pos"] ?? child.attributes.pos;
+    const val = (child.attributes["w:val"] ?? child.attributes.val ?? "left").toLowerCase();
+    const leader = (child.attributes["w:leader"] ?? child.attributes.leader ?? "none").toLowerCase();
+    if (pos === void 0) continue;
+    const position = Number.parseInt(pos, 10);
+    if (!Number.isFinite(position)) continue;
+    const align = ["left", "center", "right", "decimal", "bar", "clear"].includes(
+      val
+    ) ? val : "left";
+    const leaderValue = leader === "none" || leader === "dot" || leader === "hyphen" || leader === "underscore" || leader === "heavy" ? leader : leader === "middledot" ? "middleDot" : void 0;
+    tabStops.push({
+      position,
+      align,
+      ...leaderValue && leaderValue !== "none" ? { leader: leaderValue } : {}
+    });
+  }
+  return tabStops.length > 0 ? tabStops : void 0;
+}
+function readOnOffParagraphProperty(node, name) {
+  const propNode = node.children.find(
+    (child) => child.type === "element" && localName5(child.name) === name
+  );
+  if (!propNode) return void 0;
+  const val = (propNode.attributes["w:val"] ?? propNode.attributes.val ?? "true").toLowerCase();
+  return val !== "false" && val !== "0" && val !== "off" ? true : void 0;
+}
+function readOptionalOnOffParagraphProperty(node, name) {
+  const propNode = node.children.find(
+    (child) => child.type === "element" && localName5(child.name) === name
+  );
+  if (!propNode) return void 0;
+  const val = (propNode.attributes["w:val"] ?? propNode.attributes.val ?? "true").toLowerCase();
+  return val !== "false" && val !== "0" && val !== "off";
+}
+function readParagraphOutlineLevel(node) {
+  const propNode = node.children.find(
+    (child) => child.type === "element" && localName5(child.name) === "outlineLvl"
+  );
+  if (!propNode) return void 0;
+  const val = propNode.attributes["w:val"] ?? propNode.attributes.val;
+  if (val === void 0) return void 0;
+  const level = Number.parseInt(val, 10);
+  return Number.isFinite(level) ? level : void 0;
+}
+function readParagraphBorders(node) {
+  const borderContainer = node.children.find(
+    (child) => child.type === "element" && localName5(child.name) === "pBdr"
+  );
+  if (!borderContainer) {
+    return void 0;
+  }
+  const borders = {};
+  for (const [name, key] of [
+    ["top", "top"],
+    ["left", "left"],
+    ["bottom", "bottom"],
+    ["right", "right"],
+    ["bar", "bar"],
+    ["between", "between"]
+  ]) {
+    const borderNode = borderContainer.children.find(
+      (child) => child.type === "element" && localName5(child.name) === name
+    );
+    if (borderNode) {
+      const border = readBorder(borderNode);
+      if (border) {
+        borders[key] = border;
+      }
+    }
+  }
+  return Object.keys(borders).length > 0 ? borders : void 0;
+}
+function readParagraphShading(node) {
+  const shadingNode = node.children.find(
+    (child) => child.type === "element" && localName5(child.name) === "shd"
+  );
+  if (!shadingNode) {
+    return void 0;
+  }
+  const shading = {};
+  const fill = shadingNode.attributes["w:fill"] ?? shadingNode.attributes.fill;
+  const color = shadingNode.attributes["w:color"] ?? shadingNode.attributes.color;
+  const val = shadingNode.attributes["w:val"] ?? shadingNode.attributes.val;
+  if (fill) shading.fill = fill;
+  if (color) shading.color = color;
+  if (val) shading.val = val;
+  return Object.keys(shading).length > 0 ? shading : void 0;
+}
+function readParagraphCnfStyle(node) {
+  const cnfStyleNode = node.children.find(
+    (child) => child.type === "element" && localName5(child.name) === "cnfStyle"
+  );
+  return cnfStyleNode?.attributes["w:val"] ?? cnfStyleNode?.attributes.val;
+}
+function readBorder(node) {
+  const border = {};
+  const value = node.attributes["w:val"] ?? node.attributes.val;
+  const size = node.attributes["w:sz"] ?? node.attributes.sz;
+  const space = node.attributes["w:space"] ?? node.attributes.space;
+  const color = node.attributes["w:color"] ?? node.attributes.color;
+  if (value) border.value = value;
+  if (size !== void 0) {
+    const parsedSize = Number.parseInt(size, 10);
+    if (Number.isFinite(parsedSize)) border.size = parsedSize;
+  }
+  if (space !== void 0) {
+    const parsedSpace = Number.parseInt(space, 10);
+    if (Number.isFinite(parsedSpace)) border.space = parsedSpace;
+  }
+  if (color) border.color = color;
+  return Object.keys(border).length > 0 ? border : void 0;
+}
+function readParagraphStyleId(node) {
+  for (const child of node.children) {
+    if (child.type !== "element" || localName5(child.name) !== "pStyle") {
+      continue;
+    }
+    const styleId = child.attributes["w:val"] ?? child.attributes.val;
+    if (styleId) {
+      return styleId;
+    }
+  }
+  return void 0;
+}
+function readParagraphNumbering(node) {
+  const numberingProperties = node.children.find(
+    (child) => child.type === "element" && localName5(child.name) === "numPr"
+  );
+  if (!numberingProperties) {
+    return void 0;
+  }
+  const levelNode = numberingProperties.children.find(
+    (child) => child.type === "element" && localName5(child.name) === "ilvl"
+  );
+  const instanceNode = numberingProperties.children.find(
+    (child) => child.type === "element" && localName5(child.name) === "numId"
+  );
+  const rawLevel = levelNode?.attributes["w:val"] ?? levelNode?.attributes.val;
+  const rawInstanceId = instanceNode?.attributes["w:val"] ?? instanceNode?.attributes.val;
+  if (!rawInstanceId || rawLevel === void 0 || !/^-?\d+$/.test(rawLevel)) {
+    return void 0;
+  }
+  return {
+    numberingInstanceId: toCanonicalNumberingInstanceId(rawInstanceId),
+    level: Number.parseInt(rawLevel, 10)
+  };
+}
+function parseRun(node, sourceXml, relationships, mediaParts, sourcePartPath) {
+  const marksResult = readRunMarks(node, sourceXml);
+  if (!marksResult.supported) {
+    return [
+      {
+        type: "opaque_inline",
+        rawXml: sourceXml.slice(node.start, node.end)
+      }
+    ];
+  }
+  const marks = marksResult.marks;
+  const result = [];
+  let encounteredUnsupportedChild = false;
+  for (const child of node.children) {
+    if (child.type !== "element") {
+      continue;
+    }
+    switch (localName5(child.name)) {
+      case "rPr":
+        break;
+      case "t": {
+        const text = child.children.filter((entry) => entry.type === "text").map((entry) => entry.text).join("");
+        result.push({
+          type: "text",
+          text,
+          ...marks.length > 0 ? { marks } : {}
+        });
+        break;
+      }
+      case "tab":
+        result.push({ type: "tab" });
+        break;
+      case "sym": {
+        const symbol = parseSymbolNode(child, marks);
+        if (!symbol) {
+          encounteredUnsupportedChild = true;
+          result.push({
+            type: "opaque_inline",
+            rawXml: sourceXml.slice(child.start, child.end)
+          });
+          break;
+        }
+        result.push(symbol);
+        break;
+      }
+      case "br":
+        if (isColumnBreak(child)) {
+          result.push({ type: "column_break" });
+        } else if (isSimpleLineBreak(child)) {
+          result.push({ type: "hard_break" });
+        } else {
+          result.push({
+            type: "opaque_inline",
+            rawXml: sourceXml.slice(child.start, child.end)
+          });
+        }
+        break;
+      case "drawing": {
+        const drawingXml = sourceXml.slice(child.start, child.end);
+        try {
+          const complexContent = parseComplexContentXml(
+            drawingXml,
+            relationships,
+            mediaParts,
+            sourcePartPath
+          );
+          if (complexContent) {
+            result.push(complexContent);
+            break;
+          }
+        } catch {
+        }
+        try {
+          const shapeResult = parseShapeXml(drawingXml);
+          if (shapeResult) {
+            result.push(shapeResult);
+            break;
+          }
+        } catch {
+        }
+        const parsedMedia = parseInlineMediaXml(
+          drawingXml,
+          relationships,
+          mediaParts,
+          sourcePartPath
+        );
+        if (parsedMedia.length === 0) {
+          encounteredUnsupportedChild = true;
+          result.push({
+            type: "opaque_inline",
+            rawXml: sourceXml.slice(node.start, node.end)
+          });
+          break;
+        }
+        const semanticChildren = node.children.filter(
+          (entry) => entry.type === "element" && localName5(entry.name) !== "rPr"
+        );
+        const placementXml = semanticChildren.length === 1 ? sourceXml.slice(node.start, node.end) : sourceXml.slice(child.start, child.end);
+        result.push(
+          ...parsedMedia.map((media) => ({
+            type: "image",
+            mediaId: media.mediaId,
+            relationshipId: media.relationshipId,
+            packagePartName: media.packagePartName,
+            contentType: media.contentType,
+            filename: media.filename,
+            ...media.altText ? { altText: media.altText } : {},
+            ...media.widthEmu !== void 0 ? { widthEmu: media.widthEmu } : {},
+            ...media.heightEmu !== void 0 ? { heightEmu: media.heightEmu } : {},
+            placementXml,
+            ...media.display ? { display: media.display } : {},
+            ...media.floating ? { floating: media.floating } : {}
+          }))
+        );
+        break;
+      }
+      case "pict": {
+        const pictXml = sourceXml.slice(child.start, child.end);
+        try {
+          const vmlResult = parseVmlXml(pictXml);
+          if (vmlResult) {
+            result.push({
+              ...vmlResult,
+              rawXml: sourceXml.slice(node.start, node.end)
+            });
+            break;
+          }
+        } catch {
+        }
+        encounteredUnsupportedChild = true;
+        result.push({
+          type: "opaque_inline",
+          rawXml: pictXml
+        });
+        break;
+      }
+      case "commentReference":
+        break;
+      case "footnoteReference": {
+        const noteId = child.attributes["w:id"] ?? child.attributes.id ?? "";
+        if (noteId) {
+          result.push({
+            type: "footnote_ref",
+            noteId,
+            noteKind: "footnote"
+          });
+        }
+        break;
+      }
+      case "endnoteReference": {
+        const noteId = child.attributes["w:id"] ?? child.attributes.id ?? "";
+        if (noteId) {
+          result.push({
+            type: "footnote_ref",
+            noteId,
+            noteKind: "endnote"
+          });
+        }
+        break;
+      }
+      case "lastRenderedPageBreak":
+      case "proofErr":
+        result.push({
+          type: "opaque_inline",
+          rawXml: sourceXml.slice(child.start, child.end)
+        });
+        break;
+      default:
+        encounteredUnsupportedChild = true;
+        result.push({
+          type: "opaque_inline",
+          rawXml: sourceXml.slice(child.start, child.end)
+        });
+        break;
+    }
+  }
+  if (encounteredUnsupportedChild && result.every((child) => child.type === "opaque_inline")) {
+    return [
+      {
+        type: "opaque_inline",
+        rawXml: sourceXml.slice(node.start, node.end)
+      }
+    ];
+  }
+  return result;
+}
+function parseRevisionContainer(node, sourceXml, relationshipMap) {
+  const result = [];
+  const allowsDeletedText = localName5(node.name) === "del";
+  for (const child of node.children) {
+    if (child.type !== "element") {
+      continue;
+    }
+    switch (localName5(child.name)) {
+      case "r": {
+        const run = parseRunContentOnly(child, sourceXml, {
+          allowDeletedText: allowsDeletedText,
+          preserveUnsupportedReviewMarkup: true
+        });
+        if (!run.supported) {
+          return [
+            {
+              type: "opaque_inline",
+              rawXml: sourceXml.slice(node.start, node.end)
+            }
+          ];
+        }
+        result.push(...run.nodes);
+        break;
+      }
+      case "hyperlink": {
+        const hyperlink = parseHyperlink(child, sourceXml, relationshipMap, {
+          allowDeletedText: allowsDeletedText,
+          preserveUnsupportedReviewMarkup: true
+        });
+        if (hyperlink.type === "opaque_inline") {
+          return [
+            {
+              type: "opaque_inline",
+              rawXml: sourceXml.slice(node.start, node.end)
+            }
+          ];
+        }
+        result.push(hyperlink);
+        break;
+      }
+      case "commentRangeStart":
+      case "commentRangeEnd":
+      case "bookmarkStart":
+      case "bookmarkEnd":
+      case "proofErr":
+      case "lastRenderedPageBreak":
+        return [
+          {
+            type: "opaque_inline",
+            rawXml: sourceXml.slice(node.start, node.end)
+          }
+        ];
+      case "permStart":
+        result.push(parsePermStartNode(child, sourceXml));
+        break;
+      case "permEnd":
+        result.push(parsePermEndNode(child, sourceXml));
+        break;
+      default:
+        return [
+          {
+            type: "opaque_inline",
+            rawXml: sourceXml.slice(node.start, node.end)
+          }
+        ];
+    }
+  }
+  return result;
+}
+function parseHyperlink(node, sourceXml, relationshipMap, options = {}) {
+  const relationshipId = node.attributes["r:id"] ?? node.attributes.id;
+  const anchor = node.attributes["w:anchor"] ?? node.attributes.anchor;
+  let href;
+  if (relationshipId) {
+    const relationship = relationshipMap.get(relationshipId);
+    if (relationship && relationship.type === HYPERLINK_RELATIONSHIP_TYPE && relationship.targetMode === "external") {
+      href = relationship.target;
+    }
+  } else if (anchor) {
+    href = `#${anchor}`;
+  }
+  if (!href) {
+    return {
+      type: "opaque_inline",
+      rawXml: sourceXml.slice(node.start, node.end)
+    };
+  }
+  const children = [];
+  for (const child of node.children) {
+    if (child.type !== "element") {
+      continue;
+    }
+    if (localName5(child.name) !== "r") {
+      return {
+        type: "opaque_inline",
+        rawXml: sourceXml.slice(node.start, node.end)
+      };
+    }
+    const run = parseRunContentOnly(child, sourceXml, {
+      allowDeletedText: options.allowDeletedText,
+      preserveUnsupportedReviewMarkup: options.preserveUnsupportedReviewMarkup
+    });
+    if (!run.supported) {
+      return {
+        type: "opaque_inline",
+        rawXml: sourceXml.slice(node.start, node.end)
+      };
+    }
+    children.push(...run.nodes);
+  }
+  return {
+    type: "hyperlink",
+    href,
+    children,
+    rawXml: sourceXml.slice(node.start, node.end)
+  };
+}
+function parseRunContentOnly(node, _sourceXml, options = {}) {
+  const marksResult = readRunMarks(node, _sourceXml);
+  if (!marksResult.supported) {
+    return { nodes: [], supported: false };
+  }
+  const marks = marksResult.marks;
+  const nodes = [];
+  for (const child of node.children) {
+    if (child.type !== "element") {
+      continue;
+    }
+    switch (localName5(child.name)) {
+      case "rPr":
+        break;
+      case "t": {
+        const text = child.children.filter((entry) => entry.type === "text").map((entry) => entry.text).join("");
+        nodes.push({
+          type: "text",
+          text,
+          ...marks.length > 0 ? { marks } : {}
+        });
+        break;
+      }
+      case "delText":
+      case "delInstrText":
+        if (!options.allowDeletedText) {
+          return { nodes: [], supported: false };
+        }
+        nodes.push({
+          type: "text",
+          text: child.children.filter((entry) => entry.type === "text").map((entry) => entry.text).join(""),
+          ...marks.length > 0 ? { marks } : {}
+        });
+        break;
+      case "tab":
+        nodes.push({ type: "tab" });
+        break;
+      case "sym": {
+        const symbol = parseSymbolNode(child, marks);
+        if (!symbol) {
+          return { nodes: [], supported: false };
+        }
+        nodes.push(symbol);
+        break;
+      }
+      case "br":
+        if (isColumnBreak(child)) {
+          nodes.push({ type: "column_break" });
+          break;
+        }
+        if (!isSimpleLineBreak(child)) {
+          return { nodes: [], supported: false };
+        }
+        nodes.push({ type: "hard_break" });
+        break;
+      case "commentReference":
+      case "lastRenderedPageBreak":
+      case "proofErr":
+        if (options.preserveUnsupportedReviewMarkup) {
+          return { nodes: [], supported: false };
+        }
+        break;
+      default:
+        return { nodes: [], supported: false };
+    }
+  }
+  return { nodes, supported: true };
+}
+function readRunMarks(node, sourceXml) {
+  const properties = node.children.find(
+    (child) => child.type === "element" && localName5(child.name) === "rPr"
+  );
+  if (!properties) {
+    return { marks: [], supported: true };
+  }
+  if (properties.children.some(
+    (child) => child.type === "element" && DISALLOWED_RUN_PROPERTY_NAMES.has(localName5(child.name))
+  )) {
+    return {
+      marks: [],
+      supported: false
+    };
+  }
+  const marks = [];
+  if (hasOnOffProperty(properties, "b")) {
+    marks.push({ type: "bold" });
+  }
+  if (hasOnOffProperty(properties, "i")) {
+    marks.push({ type: "italic" });
+  }
+  if (hasUnderlineProperty(properties)) {
+    marks.push({ type: "underline" });
+  }
+  if (hasOnOffProperty(properties, "strike")) {
+    marks.push({ type: "strikethrough" });
+  }
+  if (hasOnOffProperty(properties, "dstrike")) {
+    marks.push({ type: "doubleStrikethrough" });
+  }
+  if (hasOnOffProperty(properties, "vanish")) {
+    marks.push({ type: "vanish" });
+  }
+  const langMark = readRunLang(properties);
+  if (langMark) {
+    marks.push(langMark);
+  }
+  const backgroundColorMark = readRunBackgroundColor(properties);
+  if (backgroundColorMark) {
+    marks.push(backgroundColorMark);
+  }
+  const highlightMark = readRunHighlight(properties);
+  if (highlightMark) {
+    marks.push(highlightMark);
+  }
+  const charSpacingMark = readNumericRunMark(properties, "spacing", "charSpacing");
+  if (charSpacingMark) {
+    marks.push(charSpacingMark);
+  }
+  const kerningMark = readNumericRunMark(properties, "kern", "kerning");
+  if (kerningMark) {
+    marks.push(kerningMark);
+  }
+  const positionMark = readNumericRunMark(properties, "position", "position");
+  if (positionMark) {
+    marks.push(positionMark);
+  }
+  if (hasOnOffProperty(properties, "emboss")) {
+    marks.push({ type: "emboss" });
+  }
+  if (hasOnOffProperty(properties, "imprint")) {
+    marks.push({ type: "imprint" });
+  }
+  if (hasOnOffProperty(properties, "shadow")) {
+    marks.push({ type: "shadow" });
+  }
+  const textFillMark = readRunTextFill(properties, sourceXml);
+  if (textFillMark) {
+    marks.push(textFillMark);
+  }
+  const rFontsNode = properties.children.find(
+    (child) => child.type === "element" && localName5(child.name) === "rFonts"
+  );
+  if (rFontsNode) {
+    const family = rFontsNode.attributes["w:ascii"] ?? rFontsNode.attributes["w:hAnsi"] ?? rFontsNode.attributes.ascii ?? rFontsNode.attributes.hAnsi;
+    if (family) {
+      marks.push({ type: "fontFamily", val: family });
+    }
+  }
+  const szNode = properties.children.find(
+    (child) => child.type === "element" && localName5(child.name) === "sz"
+  );
+  if (szNode) {
+    const szVal = szNode.attributes["w:val"] ?? szNode.attributes.val;
+    if (szVal) {
+      const size = Number.parseInt(szVal, 10);
+      if (Number.isFinite(size) && size > 0) {
+        marks.push({ type: "fontSize", val: size });
+      }
+    }
+  }
+  const colorNode = properties.children.find(
+    (child) => child.type === "element" && localName5(child.name) === "color"
+  );
+  if (colorNode) {
+    const colorVal = colorNode.attributes["w:val"] ?? colorNode.attributes.val;
+    if (colorVal && colorVal !== "auto") {
+      marks.push({ type: "textColor", color: colorVal });
+    }
+  }
+  if (hasOnOffProperty(properties, "smallCaps")) {
+    marks.push({ type: "smallCaps" });
+  }
+  if (hasOnOffProperty(properties, "caps")) {
+    marks.push({ type: "allCaps" });
+  }
+  return {
+    marks,
+    supported: true
+  };
+}
+function readRunLang(properties) {
+  const langNode = properties.children.find(
+    (child) => child.type === "element" && localName5(child.name) === "lang"
+  );
+  if (!langNode) return void 0;
+  const val = langNode.attributes["w:val"] ?? langNode.attributes.val ?? langNode.attributes["w:bidi"] ?? langNode.attributes.bidi;
+  if (!val) return void 0;
+  return { type: "lang", val };
+}
+function readRunBackgroundColor(properties) {
+  const shadingNode = properties.children.find(
+    (child) => child.type === "element" && localName5(child.name) === "shd"
+  );
+  if (!shadingNode) {
+    return void 0;
+  }
+  const fill = shadingNode.attributes["w:fill"] ?? shadingNode.attributes.fill;
+  if (!fill || fill === "auto") {
+    return void 0;
+  }
+  return { type: "backgroundColor", color: fill };
+}
+function readRunHighlight(properties) {
+  const highlightNode = properties.children.find(
+    (child) => child.type === "element" && localName5(child.name) === "highlight"
+  );
+  if (!highlightNode) {
+    return void 0;
+  }
+  const highlightValue = highlightNode.attributes["w:val"] ?? highlightNode.attributes.val;
+  const resolvedHighlight = resolveHighlightColor(highlightValue);
+  if (!resolvedHighlight) {
+    return void 0;
+  }
+  return {
+    type: "highlight",
+    color: resolvedHighlight.color,
+    val: resolvedHighlight.val
+  };
+}
+function readNumericRunMark(properties, elementName, markType) {
+  const propertyNode = properties.children.find(
+    (child) => child.type === "element" && localName5(child.name) === elementName
+  );
+  if (!propertyNode) {
+    return void 0;
+  }
+  const rawValue = propertyNode.attributes["w:val"] ?? propertyNode.attributes.val;
+  if (rawValue === void 0) {
+    return void 0;
+  }
+  const value = Number.parseInt(rawValue, 10);
+  if (!Number.isFinite(value)) {
+    return void 0;
+  }
+  return { type: markType, val: value };
+}
+function readRunTextFill(properties, sourceXml) {
+  const textFillNode = properties.children.find(
+    (child) => child.type === "element" && localName5(child.name) === "textFill"
+  );
+  if (!textFillNode) {
+    return void 0;
+  }
+  return {
+    type: "textFill",
+    xml: sourceXml.slice(textFillNode.start, textFillNode.end)
+  };
+}
+function parseSymbolNode(node, marks) {
+  const char = node.attributes["w:char"] ?? node.attributes.char;
+  if (!char) {
+    return void 0;
+  }
+  const font = node.attributes["w:font"] ?? node.attributes.font;
+  return {
+    type: "symbol",
+    char,
+    ...font ? { font } : {},
+    ...marks.length > 0 ? { marks } : {}
+  };
+}
+function supportsParagraphProperties(node) {
+  for (const child of node.children) {
+    if (child.type !== "element") {
+      continue;
+    }
+    const name = localName5(child.name);
+    if (name === "pPrChange") {
+      return false;
+    }
+    if (name === "rPr") {
+      if (child.children.some(
+        (entry) => entry.type === "element" && DISALLOWED_PARAGRAPH_PROPERTY_NAMES.has(localName5(entry.name))
+      )) {
+        return false;
+      }
+    }
+  }
+  return true;
+}
+var DISALLOWED_RUN_PROPERTY_NAMES = /* @__PURE__ */ new Set(["rPrChange"]);
+var DISALLOWED_PARAGRAPH_PROPERTY_NAMES = /* @__PURE__ */ new Set(["pPrChange", "rPrChange"]);
+function hasOnOffProperty(properties, propertyName) {
+  const property = properties.children.find(
+    (child) => child.type === "element" && localName5(child.name) === propertyName
+  );
+  if (!property) {
+    return false;
+  }
+  const value = (property.attributes["w:val"] ?? property.attributes.val ?? "true").toLowerCase();
+  return value !== "false" && value !== "0" && value !== "off";
+}
+function hasUnderlineProperty(properties) {
+  const property = properties.children.find(
+    (child) => child.type === "element" && localName5(child.name) === "u"
+  );
+  if (!property) {
+    return false;
+  }
+  const value = (property.attributes["w:val"] ?? property.attributes.val ?? "single").toLowerCase();
+  return value !== "none";
+}
+function isSimpleLineBreak(node) {
+  const value = (node.attributes["w:type"] ?? node.attributes.type ?? "textWrapping").toLowerCase();
+  return value === "textwrapping" || value === "line";
+}
+function isColumnBreak(node) {
+  const value = (node.attributes["w:type"] ?? node.attributes.type ?? "").toLowerCase();
+  return value === "column";
+}
+function findChildElement2(node, childLocalName) {
+  const child = node.children.find(
+    (entry) => entry.type === "element" && localName5(entry.name) === childLocalName
+  );
+  if (!child) {
+    throw new Error(`Expected <${childLocalName}> element in main document XML.`);
+  }
+  return child;
+}
+function localName5(name) {
+  const separatorIndex = name.indexOf(":");
+  return separatorIndex >= 0 ? name.slice(separatorIndex + 1) : name;
+}
+function readOptionalAttribute2(node, name) {
+  return node.attributes[`w:${name}`] ?? node.attributes[`r:${name}`] ?? node.attributes[name];
+}
+function parseXml5(xml) {
+  const root = {
+    type: "element",
+    name: "__root__",
+    attributes: {},
+    children: [],
+    start: 0,
+    end: 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: end >= 0 ? end + 3 : xml.length
+      });
+      cursor = end >= 0 ? end + 3 : xml.length;
+      continue;
+    }
+    const currentChar = xml[cursor];
+    if (currentChar !== "<") {
+      const nextTag = xml.indexOf("<", cursor);
+      const end = nextTag >= 0 ? nextTag : xml.length;
+      const text = decodeXmlEntities3(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 end = xml.indexOf(">", cursor);
+      if (end < 0) {
+        throw new Error("Malformed XML: missing closing >.");
+      }
+      const name2 = xml.slice(cursor + 2, end).trim();
+      const current = stack.pop();
+      if (!current || localName5(current.name) !== localName5(name2)) {
+        throw new Error(`Malformed XML: unexpected closing tag </${name2}>.`);
+      }
+      current.end = end + 1;
+      cursor = end + 1;
+      continue;
+    }
+    const tagEnd = findTagEnd5(xml, cursor);
+    const tagBody = xml.slice(cursor + 1, tagEnd);
+    const selfClosing = /\/\s*$/.test(tagBody);
+    const { name, attributes } = parseTag5(tagBody.replace(/\/\s*$/, "").trim());
+    const element = {
+      type: "element",
+      name,
+      attributes,
+      children: [],
+      start: cursor,
+      end: tagEnd + 1
+    };
+    stack[stack.length - 1]?.children.push(element);
+    if (!selfClosing) {
+      stack.push(element);
+    }
+    cursor = tagEnd + 1;
+  }
+  if (stack.length !== 1) {
+    throw new Error("Malformed XML: unclosed element in main document XML.");
+  }
+  return root;
+}
+function parseTag5(tagBody) {
+  let cursor = 0;
+  while (cursor < tagBody.length && /\s/.test(tagBody[cursor] ?? "")) {
+    cursor += 1;
+  }
+  const nameStart = cursor;
+  while (cursor < tagBody.length && !/\s/.test(tagBody[cursor] ?? "")) {
+    cursor += 1;
+  }
+  const name = tagBody.slice(nameStart, cursor);
+  const attributes = {};
+  while (cursor < tagBody.length) {
+    while (cursor < tagBody.length && /\s/.test(tagBody[cursor] ?? "")) {
+      cursor += 1;
+    }
+    if (cursor >= tagBody.length) {
+      break;
+    }
+    const keyStart = cursor;
+    while (cursor < tagBody.length && !/[\s=]/.test(tagBody[cursor] ?? "")) {
+      cursor += 1;
+    }
+    const key = tagBody.slice(keyStart, cursor);
+    while (cursor < tagBody.length && /\s/.test(tagBody[cursor] ?? "")) {
+      cursor += 1;
+    }
+    if (tagBody[cursor] !== "=") {
+      attributes[key] = "";
+      continue;
+    }
+    cursor += 1;
+    while (cursor < tagBody.length && /\s/.test(tagBody[cursor] ?? "")) {
+      cursor += 1;
+    }
+    const quote = tagBody[cursor];
+    if (quote !== `"` && quote !== `'`) {
+      throw new Error(`Malformed XML attribute ${key}.`);
+    }
+    cursor += 1;
+    const valueStart = cursor;
+    while (cursor < tagBody.length && tagBody[cursor] !== quote) {
+      cursor += 1;
+    }
+    const rawValue = tagBody.slice(valueStart, cursor);
+    attributes[key] = decodeXmlEntities3(rawValue);
+    cursor += 1;
+  }
+  return { name, attributes };
+}
+function findTagEnd5(xml, start) {
+  let cursor = start + 1;
+  let quote = null;
+  while (cursor < xml.length) {
+    const current = xml[cursor];
+    if (quote) {
+      if (current === quote) {
+        quote = null;
+      }
+      cursor += 1;
+      continue;
+    }
+    if (current === `"` || current === `'`) {
+      quote = current;
+      cursor += 1;
+      continue;
+    }
+    if (current === ">") {
+      return cursor;
+    }
+    cursor += 1;
+  }
+  throw new Error("Malformed XML: missing >.");
+}
+function decodeXmlEntities3(value) {
+  return value.replace(/&(#x[0-9a-fA-F]+|#\d+|amp|lt|gt|quot|apos);/g, (match, entity) => {
+    switch (entity) {
+      case "amp":
+        return "&";
+      case "lt":
+        return "<";
+      case "gt":
+        return ">";
+      case "quot":
+        return `"`;
+      case "apos":
+        return "'";
+      default:
+        if (entity.startsWith("#x")) {
+          return String.fromCodePoint(Number.parseInt(entity.slice(2), 16));
+        }
+        if (entity.startsWith("#")) {
+          return String.fromCodePoint(Number.parseInt(entity.slice(1), 10));
+        }
+        return match;
+    }
+  });
+}
+function parseSectionBreakElement(node, sourceXml) {
+  const props = parseSectionPropertiesFromElement(node);
+  return {
+    type: "section_break",
+    sectionPropertiesXml: sourceXml.slice(node.start, node.end),
+    sectionProperties: props
+  };
+}
+function readSectionPropertiesFromPPr(pPrNode) {
+  for (const child of pPrNode.children) {
+    if (child.type === "element" && localName5(child.name) === "sectPr") {
+      return parseSectionPropertiesFromElement(child);
+    }
+  }
+  return void 0;
+}
+function readSectionPropertiesXmlFromPPr(pPrNode, sourceXml) {
+  for (const child of pPrNode.children) {
+    if (child.type === "element" && localName5(child.name) === "sectPr") {
+      return sourceXml.slice(child.start, child.end);
+    }
+  }
+  return void 0;
+}
+function parseSectionPropertiesFromElement(node) {
+  const props = {};
+  for (const child of node.children) {
+    if (child.type !== "element") continue;
+    const name = localName5(child.name);
+    switch (name) {
+      case "pgSz": {
+        const w = safeParseInt(child.attributes["w:w"]);
+        const h = safeParseInt(child.attributes["w:h"]);
+        if (w !== void 0 && h !== void 0) {
+          const pageSize = { width: w, height: h };
+          const orient = child.attributes["w:orient"];
+          if (orient === "landscape" || orient === "portrait") {
+            pageSize.orientation = orient;
+          }
+          props.pageSize = pageSize;
+        }
+        break;
+      }
+      case "pgMar": {
+        const top = safeParseInt(child.attributes["w:top"]);
+        const right = safeParseInt(child.attributes["w:right"]);
+        const bottom = safeParseInt(child.attributes["w:bottom"]);
+        const left = safeParseInt(child.attributes["w:left"]);
+        if (top !== void 0 && right !== void 0 && bottom !== void 0 && left !== void 0) {
+          const margins = { top, right, bottom, left };
+          const header = safeParseInt(child.attributes["w:header"]);
+          const footer = safeParseInt(child.attributes["w:footer"]);
+          const gutter = safeParseInt(child.attributes["w:gutter"]);
+          if (header !== void 0) margins.header = header;
+          if (footer !== void 0) margins.footer = footer;
+          if (gutter !== void 0) margins.gutter = gutter;
+          props.pageMargins = margins;
+        }
+        break;
+      }
+      case "cols": {
+        const columns = {};
+        const num = safeParseInt(child.attributes["w:num"]);
+        const space = safeParseInt(child.attributes["w:space"]);
+        const equalWidth = child.attributes["w:equalWidth"];
+        const sep = child.attributes["w:sep"];
+        if (num !== void 0) columns.count = num;
+        if (space !== void 0) columns.space = space;
+        if (equalWidth !== void 0) columns.equalWidth = equalWidth !== "0" && equalWidth !== "false";
+        if (sep === "1" || sep === "true") columns.separator = true;
+        const colDefs = [];
+        for (const colChild of child.children) {
+          if (colChild.type === "element" && localName5(colChild.name) === "col") {
+            const colW = safeParseInt(colChild.attributes["w:w"]);
+            const colSpace = safeParseInt(colChild.attributes["w:space"]);
+            if (colW !== void 0) {
+              colDefs.push(colSpace !== void 0 ? { width: colW, space: colSpace } : { width: colW });
+            }
+          }
+        }
+        if (colDefs.length > 0) columns.columns = colDefs;
+        if (Object.keys(columns).length > 0) props.columns = columns;
+        break;
+      }
+      case "pgNumType": {
+        const numbering = {};
+        const fmt = child.attributes["w:fmt"];
+        const start = safeParseInt(child.attributes["w:start"]);
+        const chapStyle = child.attributes["w:chapStyle"];
+        const chapSep = child.attributes["w:chapSep"];
+        if (fmt) numbering.format = fmt;
+        if (start !== void 0) numbering.start = start;
+        if (chapStyle) numbering.chapStyle = chapStyle;
+        if (chapSep) numbering.chapSep = chapSep;
+        if (Object.keys(numbering).length > 0) props.pageNumbering = numbering;
+        break;
+      }
+      case "lnNumType": {
+        const lineNumbering = {};
+        const countBy = safeParseInt(child.attributes["w:countBy"]);
+        const start = safeParseInt(child.attributes["w:start"]);
+        const distance = safeParseInt(child.attributes["w:distance"]);
+        const restart = child.attributes["w:restart"];
+        if (countBy !== void 0) lineNumbering.countBy = countBy;
+        if (start !== void 0) lineNumbering.start = start;
+        if (distance !== void 0) lineNumbering.distance = distance;
+        if (restart === "newPage" || restart === "newSection" || restart === "continuous") {
+          lineNumbering.restart = restart;
+        }
+        if (Object.keys(lineNumbering).length > 0) {
+          props.lineNumbering = lineNumbering;
+        }
+        break;
+      }
+      case "pgBorders": {
+        const pageBorders = {};
+        const offsetFrom = child.attributes["w:offsetFrom"];
+        const display = child.attributes["w:display"];
+        const zOrder = child.attributes["w:zOrder"];
+        if (offsetFrom === "page" || offsetFrom === "text") {
+          pageBorders.offsetFrom = offsetFrom;
+        }
+        if (display === "allPages" || display === "firstPage" || display === "notFirstPage") {
+          pageBorders.display = display;
+        }
+        if (zOrder === "front" || zOrder === "back") {
+          pageBorders.zOrder = zOrder;
+        }
+        for (const borderChild of child.children) {
+          if (borderChild.type !== "element") continue;
+          const borderName = localName5(borderChild.name);
+          const border = parseBorderSpec(borderChild);
+          if (!border) continue;
+          if (borderName === "top" || borderName === "left" || borderName === "bottom" || borderName === "right") {
+            pageBorders[borderName] = border;
+          }
+        }
+        if (Object.keys(pageBorders).length > 0) {
+          props.pageBorders = pageBorders;
+        }
+        break;
+      }
+      case "docGrid": {
+        const documentGrid = {};
+        const type = child.attributes["w:type"];
+        const linePitch = safeParseInt(child.attributes["w:linePitch"]);
+        const charSpace = safeParseInt(child.attributes["w:charSpace"]);
+        if (type === "default" || type === "lines" || type === "linesAndChars" || type === "snapToChars") {
+          documentGrid.type = type;
+        }
+        if (linePitch !== void 0) documentGrid.linePitch = linePitch;
+        if (charSpace !== void 0) documentGrid.charSpace = charSpace;
+        if (Object.keys(documentGrid).length > 0) {
+          props.documentGrid = documentGrid;
+        }
+        break;
+      }
+      case "headerReference": {
+        const variant = child.attributes["w:type"];
+        const rId = child.attributes["r:id"];
+        if (variant && rId) {
+          if (!props.headerReferences) props.headerReferences = [];
+          props.headerReferences.push({ variant, relationshipId: rId });
+        }
+        break;
+      }
+      case "footerReference": {
+        const variant = child.attributes["w:type"];
+        const rId = child.attributes["r:id"];
+        if (variant && rId) {
+          if (!props.footerReferences) props.footerReferences = [];
+          props.footerReferences.push({ variant, relationshipId: rId });
+        }
+        break;
+      }
+      case "type": {
+        const val = child.attributes["w:val"];
+        if (val === "continuous" || val === "nextPage" || val === "evenPage" || val === "oddPage" || val === "nextColumn") {
+          props.sectionType = val;
+        }
+        break;
+      }
+      case "titlePg": {
+        const val = child.attributes["w:val"];
+        props.titlePage = val !== "false" && val !== "0";
+        break;
+      }
+    }
+  }
+  return props;
+}
+function safeParseInt(value) {
+  if (value === void 0) return void 0;
+  const n = Number.parseInt(value, 10);
+  return Number.isFinite(n) ? n : void 0;
+}
+function parseBorderSpec(node) {
+  const border = {};
+  const value = node.attributes["w:val"];
+  const size = safeParseInt(node.attributes["w:sz"]);
+  const space = safeParseInt(node.attributes["w:space"]);
+  const color = node.attributes["w:color"];
+  if (value) border.value = value;
+  if (size !== void 0) border.size = size;
+  if (space !== void 0) border.space = space;
+  if (color) border.color = color;
+  return Object.keys(border).length > 0 ? border : void 0;
+}
+function parsePermStartNode(node, sourceXml) {
+  const rangeId = node.attributes["w:id"] ?? node.attributes.id ?? "";
+  const edGrp = node.attributes["w:edGrp"] ?? node.attributes.edGrp;
+  const ed = node.attributes["w:ed"] ?? node.attributes.ed;
+  return {
+    type: "perm_start",
+    rangeId,
+    ...edGrp ? { editorGroup: edGrp } : {},
+    ...ed ? { editor: ed } : {},
+    rawXml: sourceXml.slice(node.start, node.end)
+  };
+}
+function parsePermEndNode(node, sourceXml) {
+  return {
+    type: "perm_end",
+    rangeId: node.attributes["w:id"] ?? node.attributes.id ?? "",
+    rawXml: sourceXml.slice(node.start, node.end)
+  };
+}
+
+export {
+  parseNumberingXml,
+  parseShapeXml,
+  parseVmlXml,
+  resolveHighlightColor,
+  parseMainDocumentXml
+};
+//# sourceMappingURL=chunk-4AQOYAW4.js.map