simple-super-doc 0.11.3

package/dist/index.js

@@ -0,0 +1,2221 @@
+// src/index.ts
+import JSZip from "jszip";
+
+// src/types.ts
+var DocxParseError = class extends Error {
+  constructor(message, code) {
+    super(message);
+    this.name = "DocxParseError";
+    this.code = code;
+  }
+};
+
+// src/parser/relationships.ts
+import { XMLParser } from "fast-xml-parser";
+var parser = new XMLParser({
+  removeNSPrefix: true,
+  attributeNamePrefix: "",
+  ignoreAttributes: false,
+  parseAttributeValue: false,
+  isArray: (name) => name === "Relationship"
+});
+function parseRelationships(xml) {
+  const doc = parser.parse(xml);
+  const rels = {};
+  const relationships = doc?.Relationships?.Relationship ?? [];
+  for (const rel of relationships) {
+    if (rel.Id && rel.Type && rel.Target) {
+      rels[rel.Id] = { type: rel.Type, target: rel.Target };
+    }
+  }
+  return rels;
+}
+
+// src/parser/styles.ts
+import { XMLParser as XMLParser2 } from "fast-xml-parser";
+var parser2 = new XMLParser2({
+  removeNSPrefix: true,
+  attributeNamePrefix: "",
+  ignoreAttributes: false,
+  parseAttributeValue: false,
+  isArray: (name) => name === "style"
+});
+var HIGHLIGHT_COLORS = {
+  yellow: "yellow",
+  green: "lime",
+  cyan: "cyan",
+  magenta: "magenta",
+  red: "red",
+  blue: "blue",
+  white: "white",
+  black: "black",
+  darkBlue: "darkblue",
+  darkCyan: "darkcyan",
+  darkGreen: "darkgreen",
+  darkMagenta: "darkmagenta",
+  darkRed: "darkred",
+  darkYellow: "#808000",
+  darkGray: "#a9a9a9",
+  lightGray: "#d3d3d3"
+};
+function extractRPr(rPr) {
+  if (!rPr) return {};
+  const s = {};
+  if ("b" in rPr) {
+    const b = rPr.b;
+    const val = typeof b === "object" && b !== null ? b.val : void 0;
+    s.bold = val === "0" || val === "false" || val === "off" ? false : true;
+  }
+  if ("i" in rPr) {
+    const i = rPr.i;
+    const val = typeof i === "object" && i !== null ? i.val : void 0;
+    s.italic = val === "0" || val === "false" || val === "off" ? false : true;
+  }
+  if ("u" in rPr) {
+    const u = rPr.u;
+    const val = typeof u === "object" && u !== null ? u.val : void 0;
+    if (val === "none" || val === "0" || val === "false" || val === "off") {
+      s.underline = false;
+    } else {
+      s.underline = true;
+    }
+  }
+  if ("strike" in rPr) {
+    const st = rPr.strike;
+    const val = typeof st === "object" && st !== null ? st.val : void 0;
+    s.strike = !(val === "0" || val === "false" || val === "off");
+  }
+  if ("vertAlign" in rPr) {
+    const va = rPr.vertAlign?.val;
+    if (va === "superscript") s.vertAlign = "super";
+    else if (va === "subscript") s.vertAlign = "sub";
+  }
+  if ("rtl" in rPr) {
+    const val = rPr.rtl?.val;
+    s.rtl = !(val === "0" || val === "false" || val === "off");
+  }
+  if ("highlight" in rPr) {
+    const val = rPr.highlight?.val;
+    const css = HIGHLIGHT_COLORS[val ?? ""];
+    if (css) s.highlight = css;
+  }
+  if ("sz" in rPr) {
+    const sz = rPr.sz;
+    const raw = typeof sz === "object" && sz !== null ? sz.val : String(sz);
+    const half = parseInt(raw, 10);
+    if (!isNaN(half)) s.fontSize = half / 2;
+  }
+  if ("rFonts" in rPr) {
+    const fonts = rPr.rFonts;
+    const family = fonts.ascii ?? fonts.hAnsi;
+    if (family) s.fontFamily = family;
+  }
+  if ("color" in rPr) {
+    const color = rPr.color;
+    const val = typeof color === "object" && color !== null ? color.val : String(color);
+    if (val && val !== "auto") s.color = val;
+  }
+  if ("shd" in rPr) {
+    const shd = rPr.shd;
+    const fill = typeof shd === "object" && shd !== null ? shd.fill : void 0;
+    if (fill && fill !== "auto") s.backgroundColor = fill;
+  }
+  return s;
+}
+var twipsToPx = (twips) => Math.round(parseFloat(twips) * 96 / 1440);
+function borderSideCss(b) {
+  if (!b || typeof b !== "object") return void 0;
+  const val = b.val;
+  if (!val) return void 0;
+  if (val === "nil" || val === "none") return "none";
+  const px = Math.max(1, Math.round((b.sz ? parseFloat(b.sz) / 8 : 0.5) * 96 / 72));
+  const lineStyle = val === "double" ? "double" : val === "dashed" ? "dashed" : val === "dotted" ? "dotted" : "solid";
+  const color = b.color && b.color !== "auto" ? `#${b.color}` : "#000";
+  return `${px}px ${lineStyle} ${color}`;
+}
+function extractBorders(node) {
+  if (!node) return {};
+  const out = {};
+  for (const side of ["top", "bottom", "left", "right", "insideH", "insideV"]) {
+    const css = borderSideCss(node[side]);
+    if (css !== void 0) out[side] = css;
+  }
+  return out;
+}
+function resolveTableBorders(styleId, rawStyles, visited) {
+  if (visited.has(styleId)) return {};
+  visited.add(styleId);
+  const raw = rawStyles[styleId];
+  if (!raw) return {};
+  let base = {};
+  const basedOn = raw.basedOn;
+  if (basedOn?.val) base = resolveTableBorders(basedOn.val, rawStyles, visited);
+  const tblPr = raw.tblPr;
+  return { ...base, ...extractBorders(tblPr?.tblBorders) };
+}
+function extractPPr(pPr) {
+  if (!pPr) return {};
+  const s = {};
+  if ("jc" in pPr) {
+    const jc = pPr.jc;
+    const val = typeof jc === "object" && jc !== null ? jc.val : String(jc);
+    if (val === "center") s.alignment = "center";
+    else if (val === "right" || val === "end") s.alignment = "right";
+    else if (val === "both" || val === "distribute" || val === "justify") s.alignment = "justify";
+    else s.alignment = "left";
+  }
+  if ("bidi" in pPr) {
+    const val = pPr.bidi?.val;
+    s.rtl = !(val === "0" || val === "false" || val === "off");
+  }
+  if ("pBdr" in pPr) {
+    const bdr = pPr.pBdr;
+    const sides = [["top", "borderTop"], ["bottom", "borderBottom"], ["left", "borderLeft"], ["right", "borderRight"]];
+    for (const [side, key] of sides) {
+      const b = bdr[side];
+      if (!b || typeof b !== "object") continue;
+      const val = b.val;
+      if (!val || val === "nil" || val === "none") continue;
+      const px = Math.max(1, Math.round((b.sz ? parseFloat(b.sz) / 8 : 0.5) * 96 / 72));
+      const lineStyle = val === "double" ? "double" : val === "dashed" ? "dashed" : val === "dotted" ? "dotted" : "solid";
+      const color = b.color && b.color !== "auto" ? `#${b.color}` : "#000";
+      s[key] = `${px}px ${lineStyle} ${color}`;
+    }
+  }
+  if ("ind" in pPr) {
+    const ind = pPr.ind;
+    if (ind && typeof ind === "object") {
+      if (ind.left != null) s.indentLeft = twipsToPx(ind.left);
+      if (ind.right != null) s.indentRight = twipsToPx(ind.right);
+      if (ind.hanging != null) s.indentHanging = twipsToPx(ind.hanging);
+      else if (ind.firstLine != null) s.indentFirstLine = twipsToPx(ind.firstLine);
+    }
+  }
+  if ("tabs" in pPr) {
+    const tabsNode = pPr.tabs?.tab;
+    const arr = Array.isArray(tabsNode) ? tabsNode : tabsNode ? [tabsNode] : [];
+    const stops = [];
+    for (const t of arr) {
+      if (!t || typeof t !== "object" || t.val === "clear" || t.pos == null) continue;
+      const v = t.val;
+      const val = v === "right" || v === "center" || v === "decimal" || v === "bar" ? v : "left";
+      const ld = t.leader;
+      const leader = ld === "dot" || ld === "middleDot" ? "dot" : ld === "hyphen" ? "hyphen" : ld === "underscore" ? "underscore" : "none";
+      stops.push({ posPx: twipsToPx(t.pos), val, leader });
+    }
+    if (stops.length) s.tabStops = stops.sort((a, b) => a.posPx - b.posPx);
+  }
+  if ("spacing" in pPr) {
+    const sp = pPr.spacing;
+    if (sp && typeof sp === "object") {
+      if (sp.before != null) s.spaceBefore = twipsToPx(sp.before);
+      if (sp.after != null) s.spaceAfter = twipsToPx(sp.after);
+      if (sp.line != null) {
+        if (sp.lineRule === "atLeast" || sp.lineRule === "exact") {
+          s.lineHeightPx = twipsToPx(sp.line);
+        } else {
+          s.lineHeight = parseFloat(sp.line) / 240;
+        }
+      }
+    }
+  }
+  return s;
+}
+function extractMarkRPr(pPr) {
+  if (!pPr || !("rPr" in pPr)) return {};
+  return extractRPr(pPr.rPr);
+}
+function resolveStyleChain(styleId, rawStyles, visited) {
+  if (visited.has(styleId)) {
+    console.warn(`[simple-super-doc] basedOn cycle detected at styleId "${styleId}"`);
+    return {};
+  }
+  visited.add(styleId);
+  const raw = rawStyles[styleId];
+  if (!raw) return {};
+  let base = {};
+  const basedOn = raw.basedOn;
+  if (basedOn?.val) {
+    base = resolveStyleChain(basedOn.val, rawStyles, visited);
+  }
+  const pPrStyle = extractPPr(raw.pPr);
+  const rPrStyle = extractRPr(raw.rPr);
+  return Object.assign({}, base, pPrStyle, rPrStyle);
+}
+function parseStyles(xml) {
+  const doc = parser2.parse(xml);
+  const styles = doc?.styles ?? {};
+  const docDefaults = {};
+  const rPrDefault = styles.docDefaults?.rPrDefault?.rPr;
+  if (rPrDefault) Object.assign(docDefaults, extractRPr(rPrDefault));
+  const pPrDefault = styles.docDefaults?.pPrDefault?.pPr;
+  if (pPrDefault) Object.assign(docDefaults, extractPPr(pPrDefault));
+  const rawStyles = {};
+  const styleList = styles.style ?? [];
+  for (const s of styleList) {
+    const style = s;
+    const id = style.styleId;
+    if (id) rawStyles[id] = style;
+  }
+  const styleMap = {};
+  for (const id of Object.keys(rawStyles)) {
+    styleMap[id] = resolveStyleChain(id, rawStyles, /* @__PURE__ */ new Set());
+  }
+  const tableBorderMap = {};
+  for (const id of Object.keys(rawStyles)) {
+    if (rawStyles[id].type !== "table") continue;
+    const borders = resolveTableBorders(id, rawStyles, /* @__PURE__ */ new Set());
+    if (Object.keys(borders).length) tableBorderMap[id] = borders;
+  }
+  return { styleMap, docDefaults, tableBorderMap };
+}
+
+// src/parser/numbering.ts
+import { XMLParser as XMLParser3 } from "fast-xml-parser";
+var parser3 = new XMLParser3({
+  removeNSPrefix: true,
+  attributeNamePrefix: "",
+  ignoreAttributes: false,
+  parseAttributeValue: false,
+  isArray: (name) => ["abstractNum", "num", "lvl", "lvlOverride"].includes(name)
+});
+function parseNumbering(xml) {
+  const doc = parser3.parse(xml);
+  const numbering = doc?.numbering ?? {};
+  const abstractNumMap = {};
+  for (const an of numbering.abstractNum ?? []) {
+    const id = String(an.abstractNumId);
+    abstractNumMap[id] = {};
+    for (const lvl of an.lvl ?? []) {
+      const ilvl = parseInt(String(lvl.ilvl), 10);
+      const fmtNode = lvl.numFmt;
+      const startNode = lvl.start;
+      const format = fmtNode?.val ?? "bullet";
+      const start = parseInt(startNode?.val ?? "1", 10);
+      abstractNumMap[id][ilvl] = { format, start: isNaN(start) ? 1 : start };
+    }
+  }
+  const numMap = {};
+  for (const n of numbering.num ?? []) {
+    const numId = String(n.numId);
+    const abstractRef = n.abstractNumId;
+    const abstractNumId = abstractRef?.val ?? "";
+    let startOverride;
+    for (const override of n.lvlOverride ?? []) {
+      const ilvl = parseInt(String(override.ilvl), 10);
+      if (ilvl === 0) {
+        const soNode = override.startOverride;
+        if (soNode?.val !== void 0) {
+          startOverride = parseInt(soNode.val, 10);
+        }
+      }
+    }
+    numMap[numId] = { abstractNumId, ...startOverride !== void 0 ? { startOverride } : {} };
+  }
+  return { abstractNumMap, numMap };
+}
+function emptyNumbering() {
+  return { abstractNumMap: {}, numMap: {} };
+}
+
+// src/parser/document.ts
+import { XMLParser as XMLParser4 } from "fast-xml-parser";
+
+// src/parser/table.ts
+function resolveVMerge(grid) {
+  if (grid.length === 0) return [];
+  const rowCount = grid.length;
+  let maxCols = 0;
+  for (const row of grid) {
+    let count = 0;
+    for (const cell of row) count += cell.colSpan;
+    maxCols = Math.max(maxCols, count);
+  }
+  const restartCell = new Array(maxCols).fill(null);
+  const output = [];
+  for (let r = 0; r < rowCount; r++) {
+    const outRow = [];
+    let col = 0;
+    for (const raw of grid[r]) {
+      const resolved = {
+        colSpan: raw.colSpan,
+        rowSpan: 1,
+        rawData: raw.rawData,
+        ...raw.backgroundColor ? { backgroundColor: raw.backgroundColor } : {}
+      };
+      if (raw.vMerge === "restart") {
+        restartCell[col] = resolved;
+        outRow.push(resolved);
+      } else if (raw.vMerge === "continue") {
+        const starter = restartCell[col];
+        if (starter) {
+          starter.rowSpan++;
+        } else {
+          outRow.push(resolved);
+        }
+      } else {
+        restartCell[col] = null;
+        outRow.push(resolved);
+      }
+      col += raw.colSpan;
+    }
+    output.push(outRow);
+  }
+  return output;
+}
+
+// src/parser/images.ts
+var MIME = {
+  png: "image/png",
+  jpg: "image/jpeg",
+  jpeg: "image/jpeg",
+  gif: "image/gif",
+  bmp: "image/bmp",
+  webp: "image/webp"
+};
+var SKIP_EXTS = /* @__PURE__ */ new Set(["emf", "wmf"]);
+function uint8ArrayToBase64(bytes) {
+  let b64 = "";
+  for (let i = 0; i < bytes.length; i += 8192) {
+    b64 += String.fromCharCode(...bytes.subarray(i, i + 8192));
+  }
+  return btoa(b64);
+}
+async function resolveImage(rId, relationshipMap, zip) {
+  const rel = relationshipMap[rId];
+  if (!rel) return null;
+  if (!rel.type.includes("image")) return null;
+  if (/^https?:\/\//i.test(rel.target)) return { src: rel.target };
+  const ext = rel.target.split(".").pop()?.toLowerCase() ?? "";
+  if (SKIP_EXTS.has(ext)) return null;
+  const mime = MIME[ext];
+  if (!mime) {
+    console.warn(`[simple-super-doc] unknown image extension ".${ext}" for "${rel.target}"`);
+    return null;
+  }
+  const entry = zip.file(`word/${rel.target}`) ?? zip.file(rel.target);
+  if (!entry) {
+    console.warn(`[simple-super-doc] image not found in zip: "${rel.target}"`);
+    return null;
+  }
+  const bytes = await entry.async("uint8array");
+  const src = `data:${mime};base64,${uint8ArrayToBase64(bytes)}`;
+  return { src };
+}
+
+// src/parser/document.ts
+var parser4 = new XMLParser4({
+  removeNSPrefix: true,
+  attributeNamePrefix: "",
+  ignoreAttributes: false,
+  parseAttributeValue: false,
+  // Preserve significant whitespace in <w:t xml:space="preserve"> runs. The
+  // default (trimValues: true) strips leading/trailing spaces, which silently
+  // joins words across runs ("WHEREAS the" -> "WHEREASthe").
+  trimValues: false,
+  isArray: (name) => [
+    "p",
+    "r",
+    "tbl",
+    "tr",
+    "tc",
+    "style",
+    "abstractNum",
+    "num",
+    "lvl",
+    "lvlOverride",
+    "hyperlink",
+    "bookmarkStart",
+    "ins",
+    "del",
+    "moveTo",
+    "moveFrom",
+    "fldSimple",
+    "footnote",
+    "endnote"
+  ].includes(name)
+});
+function getVal(node) {
+  if (node == null) return void 0;
+  if (typeof node === "object") return node.val;
+  return String(node);
+}
+function resolveNamedStyle(styleId, styleMap, docDefaults) {
+  if (!styleId) return { ...docDefaults };
+  const named = styleMap[styleId];
+  if (!named) {
+    console.warn(`[simple-super-doc] unknown style "${styleId}" \u2014 falling back to docDefaults`);
+    return { ...docDefaults };
+  }
+  return Object.assign({}, docDefaults, named);
+}
+function resolveListRef(pPr, ctx) {
+  if (!pPr) return void 0;
+  const numPr = pPr.numPr;
+  if (!numPr) return void 0;
+  const numId = getVal(numPr.numId);
+  const ilvlRaw = getVal(numPr.ilvl);
+  const ilvl = parseInt(ilvlRaw ?? "0", 10);
+  if (!numId || numId === "0") return void 0;
+  const numEntry = ctx.numMap[numId];
+  if (!numEntry) return void 0;
+  const levelMap = ctx.abstractNumMap[numEntry.abstractNumId];
+  if (!levelMap) return void 0;
+  const levelInfo = levelMap[ilvl] ?? levelMap[0];
+  if (!levelInfo) return void 0;
+  const start = numEntry.startOverride ?? levelInfo.start;
+  const ordered = levelInfo.format !== "bullet" && levelInfo.format !== "none";
+  return { numId, ilvl, ordered, start, format: levelInfo.format };
+}
+async function parseRun(r, paraStyle, ctx, href) {
+  const rPr = r.rPr;
+  if ("instrText" in r) return null;
+  if ("fldChar" in r) return null;
+  if ("footnoteRef" in r || "endnoteRef" in r) return null;
+  let lineBreak = false;
+  if ("br" in r) {
+    const br = r.br;
+    const brType = typeof br === "object" && br !== null ? br.type : void 0;
+    if (brType === "page") {
+      return { type: "run", text: "", style: Object.assign({}, paraStyle, extractRPr(rPr)), pageBreak: true };
+    }
+    if (brType === "column") return null;
+    lineBreak = true;
+  }
+  const rStyleId = getVal(rPr?.rStyle);
+  const charStyle = rStyleId ? ctx.styleMap[rStyleId] ?? {} : {};
+  const runStyle = Object.assign({}, paraStyle, charStyle, extractRPr(rPr));
+  const noteEl = r.footnoteReference ?? r.endnoteReference;
+  if (noteEl !== void 0) {
+    const isFoot = "footnoteReference" in r;
+    const id = String(noteEl.id ?? "");
+    const refs = isFoot ? ctx.footnoteRefs : ctx.endnoteRefs;
+    refs.push(id);
+    const marker = {
+      type: "run",
+      text: String(refs.length),
+      style: runStyle,
+      noteRef: { type: isFoot ? "footnote" : "endnote", number: refs.length }
+    };
+    return marker;
+  }
+  if ("drawing" in r) {
+    const drawing = r.drawing;
+    const anchor = drawing.anchor;
+    const inline = drawing.inline;
+    const isPageBackground = !inline && !!anchor && String(anchor.behindDoc ?? "0") === "1";
+    const drawingEl = inline ?? anchor;
+    if (!drawingEl) return null;
+    const extent = drawingEl.extent;
+    const cx = parseInt(extent?.cx ?? "0", 10);
+    const cy = parseInt(extent?.cy ?? "0", 10);
+    const rId = findBlipEmbed(drawingEl);
+    if (!rId) return null;
+    const resolved = await resolveImage(rId, ctx.relationshipMap, ctx.zip);
+    if (!resolved) return null;
+    const img = {
+      type: "image",
+      src: resolved.src,
+      widthPx: Math.round(cx / 9525),
+      heightPx: Math.round(cy / 9525),
+      ...isPageBackground ? { isPageBackground: true } : {},
+      ...href ? { href } : {}
+    };
+    return img;
+  }
+  if ("pict" in r) {
+    const vml = findVmlImage(r.pict);
+    if (vml) {
+      const resolved = await resolveImage(vml.id, ctx.relationshipMap, ctx.zip);
+      if (resolved) {
+        const ptToPx = (pt) => pt ? Math.round(parseFloat(pt) * 96 / 72) : 0;
+        return {
+          type: "image",
+          src: resolved.src,
+          widthPx: ptToPx(/width:([\d.]+)pt/.exec(vml.style ?? "")?.[1]),
+          heightPx: ptToPx(/height:([\d.]+)pt/.exec(vml.style ?? "")?.[1]),
+          ...href ? { href } : {}
+        };
+      }
+    }
+    return null;
+  }
+  const tNode = r.t ?? r.delText;
+  let text = "";
+  if (typeof tNode === "string") {
+    text = tNode;
+  } else if (typeof tNode === "object" && tNode !== null) {
+    const t = tNode;
+    text = String(t["#text"] ?? t._ ?? "");
+  } else if (tNode != null) {
+    text = String(tNode);
+  }
+  const tabNode = r.tab;
+  const tabs = Array.isArray(tabNode) ? tabNode.length : "tab" in r ? 1 : 0;
+  const textRun = {
+    type: "run",
+    text,
+    style: runStyle,
+    ...href ? { href } : {},
+    ...lineBreak ? { lineBreak: true } : {},
+    ...tabs ? { tabs } : {}
+  };
+  return textRun;
+}
+function resolveHyperlinkHref(hl, ctx) {
+  const rId = hl.id;
+  if (typeof rId === "string") {
+    const rel = ctx.relationshipMap[rId];
+    if (rel?.target) return rel.target;
+  }
+  const anchor = hl.anchor;
+  if (typeof anchor === "string" && anchor) return `#${anchor}`;
+  return void 0;
+}
+function findBlipEmbed(node) {
+  if (!node || typeof node !== "object") return void 0;
+  const obj = node;
+  if ("embed" in obj && typeof obj.embed === "string") return obj.embed;
+  if ("link" in obj && typeof obj.link === "string") return obj.link;
+  for (const v of Object.values(obj)) {
+    const found = findBlipEmbed(v);
+    if (found) return found;
+  }
+  return void 0;
+}
+function findVmlImage(node) {
+  if (!node || typeof node !== "object") return void 0;
+  if (Array.isArray(node)) {
+    for (const x of node) {
+      const f = findVmlImage(x);
+      if (f) return f;
+    }
+    return void 0;
+  }
+  const obj = node;
+  if ("imagedata" in obj) {
+    const imgs = Array.isArray(obj.imagedata) ? obj.imagedata : [obj.imagedata];
+    for (const im of imgs) {
+      const styleRaw = Array.isArray(obj.style) ? obj.style[0] : obj.style;
+      if (im?.id) return { id: im.id, style: typeof styleRaw === "string" ? styleRaw : void 0 };
+    }
+  }
+  for (const v of Object.values(obj)) {
+    const f = findVmlImage(v);
+    if (f) return f;
+  }
+  return void 0;
+}
+async function parseParagraph(p, ctx, rawXml) {
+  const pPr = p.pPr;
+  const pStyleId = getVal(pPr?.pStyle);
+  const namedStyle = resolveNamedStyle(pStyleId, ctx.styleMap, ctx.docDefaults);
+  const pPrStyle = extractPPr(pPr);
+  const paraStyle = Object.assign({}, namedStyle, pPrStyle);
+  const list = resolveListRef(pPr, ctx);
+  let pageBreakBefore = false;
+  if (pPr && "pageBreakBefore" in pPr) {
+    const val = getVal(pPr.pageBreakBefore);
+    pageBreakBefore = !(val === "0" || val === "false" || val === "off");
+  }
+  const directRuns = p.r ?? [];
+  const insList = p.ins ?? [];
+  const delList = p.del ?? [];
+  const moveToList = p.moveTo ?? [];
+  const moveFromList = p.moveFrom ?? [];
+  const hyperlinks = p.hyperlink ?? [];
+  const fldSimpleList = p.fldSimple ?? [];
+  const runChildInputs = (node, flag) => {
+    const inner = node.r;
+    const arr = Array.isArray(inner) ? inner : inner ? [inner] : [];
+    return arr.map((r) => ({ r, [flag]: true }));
+  };
+  const insInputs = (ins) => runChildInputs(ins, "inserted");
+  const delInputs = (del) => runChildInputs(del, "deleted");
+  const hlInputs = (hl) => {
+    const href = resolveHyperlinkHref(hl, ctx);
+    const inner = hl.r;
+    if (Array.isArray(inner)) return inner.map((r) => ({ r, href }));
+    return inner ? [{ r: inner, href }] : [];
+  };
+  const order = rawXml ? getRunOrder(rawXml) : [];
+  const counts = { r: 0, hyperlink: 0, ins: 0, del: 0, moveTo: 0, moveFrom: 0, fldSimple: 0 };
+  for (const t of order) counts[t]++;
+  const orderOk = order.length > 0 && counts.r === directRuns.length && counts.hyperlink === hyperlinks.length && counts.ins === insList.length && counts.del === delList.length && counts.moveTo === moveToList.length && counts.moveFrom === moveFromList.length && counts.fldSimple === fldSimpleList.length;
+  const inputs = [];
+  if (orderOk) {
+    let ri = 0, hi = 0, ii = 0, di = 0, mti = 0, mfi = 0, fi = 0;
+    for (const t of order) {
+      if (t === "r") inputs.push({ r: directRuns[ri++] });
+      else if (t === "hyperlink") inputs.push(...hlInputs(hyperlinks[hi++]));
+      else if (t === "ins") inputs.push(...insInputs(insList[ii++]));
+      else if (t === "del") inputs.push(...delInputs(delList[di++]));
+      else if (t === "moveTo") inputs.push(...runChildInputs(moveToList[mti++], "inserted"));
+      else if (t === "moveFrom") inputs.push(...runChildInputs(moveFromList[mfi++], "deleted"));
+      else inputs.push({ fldSimple: fldSimpleList[fi++] });
+    }
+  } else {
+    for (const r of directRuns) inputs.push({ r });
+    for (const ins of insList) inputs.push(...insInputs(ins));
+    for (const del of delList) inputs.push(...delInputs(del));
+    for (const mt of moveToList) inputs.push(...runChildInputs(mt, "inserted"));
+    for (const mf of moveFromList) inputs.push(...runChildInputs(mf, "deleted"));
+    for (const hl of hyperlinks) inputs.push(...hlInputs(hl));
+    for (const fs of fldSimpleList) inputs.push({ fldSimple: fs });
+  }
+  const LIVE_FIELDS = /* @__PURE__ */ new Set(["PAGE", "NUMPAGES", "SECTIONPAGES"]);
+  const fieldStack = [];
+  const runs = [];
+  for (const inp of inputs) {
+    if (inp.fldSimple) {
+      const fs = inp.fldSimple;
+      const field = String(fs.instr ?? "").trim().toUpperCase().split(/\s+/)[0];
+      const innerRuns = Array.isArray(fs.r) ? fs.r : fs.r ? [fs.r] : [];
+      const mStyle = Object.assign({}, paraStyle, extractRPr(innerRuns[0]?.rPr));
+      if (field === "PAGE") runs.push({ type: "run", text: "", style: mStyle, pageNumber: true });
+      else if (field === "NUMPAGES" || field === "SECTIONPAGES") runs.push({ type: "run", text: "", style: mStyle, totalPages: true });
+      else {
+        for (const ir of innerRuns) {
+          const run2 = await parseRun(ir, paraStyle, ctx);
+          if (run2 !== null) runs.push(run2);
+        }
+      }
+      continue;
+    }
+    const r = inp.r;
+    const { href, deleted, inserted } = inp;
+    const fldChars = "fldChar" in r ? Array.isArray(r.fldChar) ? r.fldChar : [r.fldChar] : [];
+    const hasInstr = "instrText" in r;
+    if (fldChars.length || hasInstr) {
+      for (const fc of fldChars) if (fc?.fldCharType === "begin") fieldStack.push({ name: "", inResult: false });
+      if (hasInstr) {
+        const instr = (typeof r.instrText === "object" && r.instrText !== null ? String(r.instrText["#text"] ?? "") : String(r.instrText)).trim().toUpperCase();
+        const field = instr.split(/\s+/)[0];
+        if (fieldStack.length) fieldStack[fieldStack.length - 1].name = field;
+        const mStyle = Object.assign({}, paraStyle, extractRPr(r.rPr));
+        if (field === "PAGE") runs.push({ type: "run", text: "", style: mStyle, pageNumber: true });
+        else if (field === "NUMPAGES" || field === "SECTIONPAGES") runs.push({ type: "run", text: "", style: mStyle, totalPages: true });
+      }
+      for (const fc of fldChars) if (fc?.fldCharType === "separate") {
+        if (fieldStack.length) fieldStack[fieldStack.length - 1].inResult = true;
+      }
+      for (const fc of fldChars) if (fc?.fldCharType === "end") fieldStack.pop();
+      continue;
+    }
+    if (fieldStack.some((f) => f.inResult && LIVE_FIELDS.has(f.name))) continue;
+    const run = await parseRun(r, paraStyle, ctx, href);
+    if (run !== null) {
+      if (deleted && run.type === "run") run.deleted = true;
+      if (inserted && run.type === "run") run.inserted = true;
+      runs.push(run);
+    }
+  }
+  const segments = [[]];
+  for (const run of runs) {
+    if (run.type === "run" && run.pageBreak) segments.push([]);
+    else segments[segments.length - 1].push(run);
+  }
+  const makeBlock = (segRuns, forceBreak) => {
+    const hasVisible = segRuns.some((r) => r.type === "image" || r.text.trim().length > 0);
+    const blockStyle = hasVisible ? paraStyle : Object.assign({}, paraStyle, extractMarkRPr(pPr));
+    return {
+      type: "paragraph",
+      style: blockStyle,
+      runs: segRuns,
+      ...list ? { list } : {},
+      ...forceBreak ? { pageBreakBefore: true } : {}
+    };
+  };
+  const blocks = segments.map((seg, i) => makeBlock(seg, i === 0 ? pageBreakBefore : true));
+  const sectPr = pPr?.sectPr;
+  const sectionPageSize = pageSizeFromSectPr(sectPr);
+  if (sectionPageSize) {
+    const last = blocks[blocks.length - 1];
+    last.sectionPageSize = sectionPageSize;
+    const refs = refsFromSectPr(sectPr);
+    if (refs) last.sectionRefs = refs;
+  }
+  const textBoxes = await extractTextBoxes(p, ctx);
+  return textBoxes.length ? [...blocks, ...textBoxes] : blocks;
+}
+async function extractTextBoxes(p, ctx) {
+  const contents = [];
+  collectTxbxContent(p, contents);
+  const blocks = [];
+  for (const tc of contents) blocks.push(...await parseBlockContainer(tc, ctx));
+  return blocks;
+}
+function collectTxbxContent(node, acc) {
+  if (!node || typeof node !== "object") return;
+  if (Array.isArray(node)) {
+    for (const item of node) collectTxbxContent(item, acc);
+    return;
+  }
+  for (const [key, value] of Object.entries(node)) {
+    if (key === "txbxContent") {
+      for (const tc of Array.isArray(value) ? value : [value]) {
+        if (tc && typeof tc === "object") acc.push(tc);
+      }
+    } else if (key === "AlternateContent") {
+      for (const ac of Array.isArray(value) ? value : [value]) {
+        const a = ac;
+        collectTxbxContent(a.Choice ?? a.Fallback, acc);
+      }
+    } else {
+      collectTxbxContent(value, acc);
+    }
+  }
+}
+function refsFromSectPr(sectPr) {
+  if (!sectPr) return void 0;
+  const defaultRId = (node) => {
+    const refs = Array.isArray(node) ? node : node ? [node] : [];
+    const def = refs.find((r) => r.type === "default") ?? refs[0];
+    return def?.id;
+  };
+  const headerRId = defaultRId(sectPr.headerReference);
+  const footerRId = defaultRId(sectPr.footerReference);
+  if (!headerRId && !footerRId) return void 0;
+  return { ...headerRId ? { headerRId } : {}, ...footerRId ? { footerRId } : {} };
+}
+async function parseTable(tbl, ctx, rawTableXml) {
+  const rows = tbl.tr ?? [];
+  const tblPrForBorders = tbl.tblPr;
+  const tblStyleId = getVal(tblPrForBorders?.tblStyle);
+  const styleBorders = tblStyleId && ctx.tableBorderMap[tblStyleId] || {};
+  const tableBorders = {
+    ...styleBorders,
+    ...extractBorders(tblPrForBorders?.tblBorders)
+  };
+  const definedSide = (...vals) => vals.find((v) => v && v !== "none");
+  const uniformBorder = definedSide(
+    tableBorders.insideH,
+    tableBorders.insideV,
+    tableBorders.top,
+    tableBorders.bottom,
+    tableBorders.left,
+    tableBorders.right
+  );
+  const tcXmlMap = /* @__PURE__ */ new Map();
+  if (rawTableXml) {
+    const cellInners = extractRowCellInners(rawTableXml);
+    for (let ri = 0; ri < rows.length; ri++) {
+      const cells = rows[ri].tc ?? [];
+      const rawRowInners = cellInners[ri];
+      if (rawRowInners && rawRowInners.length === cells.length) {
+        for (let ci = 0; ci < cells.length; ci++) tcXmlMap.set(cells[ci], rawRowInners[ci]);
+      }
+    }
+  }
+  const rawGrid = [];
+  for (const tr of rows) {
+    const cells = tr.tc ?? [];
+    const rawRow = [];
+    for (const tc of cells) {
+      const tcPr = tc.tcPr;
+      const colSpan = parseInt(getVal(tcPr?.gridSpan) ?? "1", 10) || 1;
+      const vMergeNode = tcPr?.vMerge;
+      let vMerge = "none";
+      if (vMergeNode !== void 0) {
+        const val = getVal(vMergeNode);
+        vMerge = val === "restart" ? "restart" : "continue";
+      }
+      const tcShd = tcPr?.shd;
+      const cellBg = tcShd?.fill && tcShd.fill !== "auto" ? tcShd.fill : void 0;
+      rawRow.push({ colSpan, vMerge, rawData: tc, backgroundColor: cellBg });
+    }
+    rawGrid.push(rawRow);
+  }
+  const resolved = resolveVMerge(rawGrid);
+  const irRows = [];
+  for (let ri = 0; ri < resolved.length; ri++) {
+    const resolvedRow = resolved[ri];
+    const irCells = [];
+    for (const cell of resolvedRow) {
+      const tc = cell.rawData;
+      const cellXml = tcXmlMap.get(tc);
+      const cellOrder = cellXml ? blockOrderOf(cellXml) : void 0;
+      const cellParaXmls = cellXml ? paragraphChunksOf(cellXml) : void 0;
+      const cellTableXmls = cellXml ? tableChunksOf(cellXml) : void 0;
+      const cellBlocks = await parseBlockContainer(tc, ctx, cellOrder, cellParaXmls, cellTableXmls);
+      const irCell = { rowSpan: cell.rowSpan, colSpan: cell.colSpan, blocks: cellBlocks };
+      if (cell.backgroundColor) irCell.backgroundColor = cell.backgroundColor;
+      const border = resolveCellBorder(tc.tcPr, uniformBorder);
+      if (border) irCell.border = border;
+      irCells.push(irCell);
+    }
+    const irRow = { cells: irCells };
+    const trH = rows[ri]?.trPr?.trHeight;
+    if (trH?.val != null) {
+      const px = Math.round(parseFloat(trH.val) * 96 / 1440);
+      if (px > 0) {
+        irRow.heightPx = px;
+        if (trH.hRule === "exact") irRow.heightExact = true;
+      }
+    }
+    irRows.push(irRow);
+  }
+  const grid = tbl.tblGrid;
+  const colsNode = grid?.gridCol;
+  const colArr = Array.isArray(colsNode) ? colsNode : colsNode ? [colsNode] : [];
+  const columnWidths = colArr.map((c) => {
+    const w = c.w;
+    return w != null ? Math.round(parseFloat(w) * 96 / 1440) : 0;
+  });
+  const tblPr = tbl.tblPr;
+  const firstTc = (rows[0]?.tc ?? [])[0];
+  const firstTcPr = firstTc?.tcPr;
+  const marNode = tblPr?.tblCellMar ?? firstTcPr?.tcMar;
+  const cellPadding = marginToPx(marNode);
+  const jc = getVal(tblPr?.jc);
+  const align = jc === "center" ? "center" : jc === "right" || jc === "end" ? "right" : void 0;
+  return {
+    type: "table",
+    rows: irRows,
+    ...columnWidths.some((w) => w > 0) ? { columnWidths } : {},
+    ...cellPadding ? { cellPadding } : {},
+    ...align ? { align } : {}
+  };
+}
+function resolveCellBorder(tcPr, uniform) {
+  const tcb = extractBorders(tcPr?.tcBorders);
+  const side = (s) => s === "none" ? void 0 : s ?? uniform;
+  const b = {};
+  const top = side(tcb.top), right = side(tcb.right), bottom = side(tcb.bottom), left = side(tcb.left);
+  if (top) b.top = top;
+  if (right) b.right = right;
+  if (bottom) b.bottom = bottom;
+  if (left) b.left = left;
+  return b.top || b.right || b.bottom || b.left ? b : void 0;
+}
+function pageSizeFromSectPr(sectPr) {
+  if (!sectPr) return void 0;
+  const twips = (v) => Math.round(parseFloat(String(v)) * 96 / 1440);
+  const pgSz = sectPr.pgSz;
+  if (!pgSz || pgSz.w == null || pgSz.h == null) return void 0;
+  const pgMar = sectPr.pgMar ?? {};
+  const m = (v, d) => v != null ? twips(v) : d;
+  const size = {
+    widthPx: twips(pgSz.w),
+    heightPx: twips(pgSz.h),
+    marginPx: {
+      top: m(pgMar.top, 96),
+      right: m(pgMar.right, 96),
+      bottom: m(pgMar.bottom, 96),
+      left: m(pgMar.left, 96)
+    }
+  };
+  if (pgMar.footer != null) size.footerPx = twips(pgMar.footer);
+  if (pgMar.header != null) size.headerPx = twips(pgMar.header);
+  return size;
+}
+function marginToPx(node) {
+  if (!node) return void 0;
+  const side = (s) => {
+    const w = s?.w;
+    return w != null ? Math.round(parseFloat(w) * 96 / 1440) : 0;
+  };
+  return { top: side(node.top), right: side(node.right), bottom: side(node.bottom), left: side(node.left) };
+}
+function bodyInner(xml) {
+  const bodyStart = xml.indexOf("<w:body>");
+  const bodyEnd = xml.lastIndexOf("</w:body>");
+  if (bodyStart === -1 || bodyEnd === -1) return "";
+  return xml.slice(bodyStart + 8, bodyEnd);
+}
+function paragraphChunksOf(inner) {
+  const chunks = [];
+  const re = /<(\/?)w:(p|tbl)[\s>\/]/g;
+  let tblDepth = 0;
+  let pStart = -1;
+  let m;
+  while ((m = re.exec(inner)) !== null) {
+    const isClose = m[1] === "/";
+    const tag = m[2];
+    if (tag === "tbl") {
+      if (isClose) tblDepth = Math.max(0, tblDepth - 1);
+      else tblDepth++;
+      continue;
+    }
+    if (tblDepth !== 0) continue;
+    if (!isClose) {
+      const gt = inner.indexOf(">", m.index);
+      if (gt > 0 && inner[gt - 1] === "/") chunks.push(inner.slice(m.index, gt + 1));
+      else if (pStart === -1) pStart = m.index;
+    } else if (pStart !== -1) {
+      const gt = inner.indexOf(">", m.index);
+      chunks.push(inner.slice(pStart, gt + 1));
+      pStart = -1;
+    }
+  }
+  return chunks;
+}
+function extractParagraphChunks(xml) {
+  return paragraphChunksOf(bodyInner(xml));
+}
+function tableChunksOf(inner) {
+  const chunks = [];
+  const re = /<(\/?)w:tbl[\s>\/]/g;
+  let tblDepth = 0;
+  let start = -1;
+  let m;
+  while ((m = re.exec(inner)) !== null) {
+    const isClose = m[1] === "/";
+    if (!isClose) {
+      if (tblDepth === 0) start = m.index;
+      tblDepth++;
+    } else {
+      tblDepth = Math.max(0, tblDepth - 1);
+      if (tblDepth === 0 && start !== -1) {
+        const gt = inner.indexOf(">", m.index);
+        chunks.push(inner.slice(start, gt + 1));
+        start = -1;
+      }
+    }
+  }
+  return chunks;
+}
+function extractTableChunks(xml) {
+  return tableChunksOf(bodyInner(xml));
+}
+function extractRowCellInners(tableXml) {
+  const rows = [];
+  let tblDepth = 0;
+  let curRow = null;
+  let tcStart = -1;
+  const re = /<(\/?)w:(tbl|tr|tc)[\s>\/]/g;
+  let m;
+  while ((m = re.exec(tableXml)) !== null) {
+    const isClose = m[1] === "/";
+    const tag = m[2];
+    if (tag === "tbl") {
+      if (isClose) tblDepth = Math.max(0, tblDepth - 1);
+      else tblDepth++;
+      continue;
+    }
+    if (tblDepth !== 1) continue;
+    if (tag === "tr") {
+      if (isClose) {
+        if (curRow) {
+          rows.push(curRow);
+          curRow = null;
+        }
+      } else curRow = [];
+      continue;
+    }
+    if (isClose) {
+      if (curRow && tcStart !== -1) {
+        curRow.push(tableXml.slice(tcStart, m.index));
+        tcStart = -1;
+      }
+    } else {
+      const gt = tableXml.indexOf(">", m.index);
+      if (gt > 0 && tableXml[gt - 1] === "/") {
+        if (curRow) curRow.push("");
+      } else tcStart = gt + 1;
+    }
+  }
+  return rows;
+}
+function getRunOrder(paraXml) {
+  let body = paraXml;
+  const pprEnd = body.indexOf("</w:pPr>");
+  if (pprEnd !== -1) body = body.slice(pprEnd + 8);
+  const order = [];
+  const re = /<(\/?)w:(r|hyperlink|ins|del|moveTo|moveFrom|fldSimple)[\s>\/]/g;
+  let depth = 0;
+  let inRun = false;
+  let m;
+  while ((m = re.exec(body)) !== null) {
+    const isClose = m[1] === "/";
+    const tag = m[2];
+    if (tag === "r") {
+      if (isClose) inRun = false;
+      else {
+        if (depth === 0) order.push("r");
+        inRun = true;
+      }
+      continue;
+    }
+    if (inRun) continue;
+    if (isClose) {
+      depth = Math.max(0, depth - 1);
+      continue;
+    }
+    const gt = body.indexOf(">", m.index);
+    const selfClose = gt > 0 && body[gt - 1] === "/";
+    if (depth === 0) order.push(tag);
+    if (!selfClose) depth++;
+  }
+  return order;
+}
+function blockOrderOf(inner) {
+  const order = [];
+  const re = /<(\/?)w:(p|tbl)[\s>\/]/g;
+  let tblDepth = 0;
+  let m;
+  while ((m = re.exec(inner)) !== null) {
+    const isClose = m[1] === "/";
+    const tag = m[2];
+    if (isClose) {
+      if (tag === "tbl") tblDepth = Math.max(0, tblDepth - 1);
+    } else {
+      if (tblDepth === 0) order.push(tag);
+      if (tag === "tbl") tblDepth++;
+    }
+  }
+  return order;
+}
+function getBodyBlockOrder(xml) {
+  return blockOrderOf(bodyInner(xml));
+}
+async function parseBlockContainer(container, ctx, order, paraXmls, tableXmls) {
+  const ps = container.p ?? [];
+  const tbls = container.tbl ?? [];
+  const xmls = paraXmls && paraXmls.length === ps.length ? paraXmls : void 0;
+  const tXmls = tableXmls && tableXmls.length === tbls.length ? tableXmls : void 0;
+  if (!order || order.length === 0) {
+    const blocks2 = [];
+    for (let i = 0; i < ps.length; i++) blocks2.push(...await parseParagraph(ps[i], ctx, xmls?.[i]));
+    for (let i = 0; i < tbls.length; i++) blocks2.push(await parseTable(tbls[i], ctx, tXmls?.[i]));
+    return blocks2;
+  }
+  const blocks = [];
+  let pIdx = 0, tblIdx = 0;
+  for (const type of order) {
+    if (type === "p" && pIdx < ps.length) {
+      blocks.push(...await parseParagraph(ps[pIdx], ctx, xmls?.[pIdx]));
+      pIdx++;
+    } else if (type === "tbl" && tblIdx < tbls.length) {
+      blocks.push(await parseTable(tbls[tblIdx], ctx, tXmls?.[tblIdx]));
+      tblIdx++;
+    }
+  }
+  return blocks;
+}
+function inlineOmmlText(xml) {
+  xml = xml.replace(/<m:oMath\b[\s\S]*?<\/m:oMath>/g, (frag) => {
+    const text = (frag.match(/<m:t\b[^>]*>([\s\S]*?)<\/m:t>/g) || []).map((t) => t.replace(/<[^>]+>/g, "")).join("");
+    return text ? `<w:r><w:t xml:space="preserve">${text}</w:t></w:r>` : "";
+  });
+  return xml.replace(/<m:oMathParaPr\b[^>]*\/>/g, "").replace(/<m:oMathParaPr\b[\s\S]*?<\/m:oMathParaPr>/g, "").replace(/<\/?m:oMathPara\b[^>]*>/g, "");
+}
+function stripTransparentWrappers(xml) {
+  return xml.replace(/<w:sdtPr\b[^>]*\/>/g, "").replace(/<w:sdtPr\b[\s\S]*?<\/w:sdtPr>/g, "").replace(/<w:sdtEndPr\b[^>]*\/>/g, "").replace(/<w:sdtEndPr\b[\s\S]*?<\/w:sdtEndPr>/g, "").replace(/<w:smartTagPr\b[^>]*\/>/g, "").replace(/<w:smartTagPr\b[\s\S]*?<\/w:smartTagPr>/g, "").replace(/<w:customXmlPr\b[^>]*\/>/g, "").replace(/<w:customXmlPr\b[\s\S]*?<\/w:customXmlPr>/g, "").replace(/<\/?w:sdtContent\b[^>]*>/g, "").replace(/<\/?w:sdt\b[^>]*>/g, "").replace(/<\/?w:smartTag\b[^>]*>/g, "").replace(/<\/?w:customXml\b[^>]*>/g, "");
+}
+async function parseDocument(xml, ctx) {
+  xml = stripTransparentWrappers(inlineOmmlText(xml));
+  const doc = parser4.parse(xml);
+  const body = doc?.document?.body;
+  if (!body) return [];
+  const order = getBodyBlockOrder(xml);
+  const paraXmls = extractParagraphChunks(xml);
+  const tableXmls = extractTableChunks(xml);
+  return parseBlockContainer(body, ctx, order, paraXmls, tableXmls);
+}
+async function parseFooterXml(xml, ctx) {
+  xml = stripTransparentWrappers(inlineOmmlText(xml));
+  const doc = parser4.parse(xml);
+  const ftr = doc?.ftr;
+  if (!ftr) return [];
+  return parseBlockContainer(ftr, ctx);
+}
+async function parseHeaderXml(xml, ctx) {
+  xml = stripTransparentWrappers(inlineOmmlText(xml));
+  const doc = parser4.parse(xml);
+  const hdr = doc?.hdr;
+  if (!hdr) return [];
+  return parseBlockContainer(hdr, ctx);
+}
+async function parseNotesXml(xml, kind, ctx) {
+  const map = /* @__PURE__ */ new Map();
+  xml = stripTransparentWrappers(inlineOmmlText(xml));
+  const doc = parser4.parse(xml);
+  const root = doc?.[`${kind}s`];
+  const notes = root?.[kind] ?? [];
+  for (const note of notes) {
+    const id = String(note.id ?? "");
+    const type = note.type;
+    if (type === "separator" || type === "continuationSeparator") continue;
+    map.set(id, await parseBlockContainer(note, ctx));
+  }
+  return map;
+}
+
+// src/renderer/layout.ts
+var EMPTY_LINE_EM = 1.7;
+var LINE_HEIGHT = 1.15;
+var HEADING_MIN_PT = 24;
+function extractPageBackground(block) {
+  for (const run of block.runs) {
+    if (run.type === "image" && run.isPageBackground) return run;
+  }
+  return null;
+}
+function isWatermark(img, pw, ph) {
+  if (img.isPageBackground) return false;
+  return img.heightPx >= ph * 0.4 && img.widthPx < pw * 0.85;
+}
+function isPageLevelImage(run, pw, ph) {
+  return run.type === "image" && (run.isPageBackground || isWatermark(run, pw, ph));
+}
+function flowOnly(block, pw, ph) {
+  const hadPageImage = block.runs.some((r) => isPageLevelImage(r, pw, ph));
+  const runs = block.runs.filter((r) => !isPageLevelImage(r, pw, ph));
+  if (hadPageImage) {
+    const hasContent = runs.some((r) => r.type !== "run" || r.text.length > 0);
+    if (!hasContent) return null;
+  }
+  return { ...block, runs };
+}
+function watermarksOf(block, pw, ph) {
+  if (block.type !== "paragraph") return [];
+  return block.runs.filter(
+    (r) => r.type === "image" && isWatermark(r, pw, ph)
+  );
+}
+function isBlockVisible(block) {
+  if (block.type === "table") return true;
+  for (const run of block.runs) {
+    if (run.type === "image") return true;
+    if (run.text.trim().length > 0) return true;
+  }
+  return false;
+}
+function headingImage(block) {
+  if (block.type !== "paragraph") return false;
+  for (const run of block.runs) {
+    if (run.type !== "image") continue;
+    const img = run;
+    if (img.isPageBackground) continue;
+    if (img.widthPx >= 300 && img.heightPx <= 70 && img.widthPx / img.heightPx >= 5) {
+      return true;
+    }
+  }
+  return false;
+}
+function isHeadingBlock(block) {
+  if (block.type !== "paragraph") return false;
+  if (headingImage(block)) return true;
+  for (const run of block.runs) {
+    if (run.type === "run" && run.text.trim() && (run.style.fontSize ?? 0) >= HEADING_MIN_PT) {
+      return true;
+    }
+  }
+  return false;
+}
+function isIconOnly(block) {
+  if (block.type !== "paragraph") return false;
+  let img = null;
+  for (const run of block.runs) {
+    if (run.type === "image") {
+      if (img) return false;
+      img = run;
+    } else if (run.text.trim().length > 0) {
+      return false;
+    }
+  }
+  return !!img && img.widthPx <= 150 && img.heightPx <= 150 && !img.isPageBackground;
+}
+function fullPageImage(blocks, pageWidthPx) {
+  let found = null;
+  for (const block of blocks) {
+    if (block.type !== "paragraph") {
+      if (isBlockVisible(block)) return null;
+      continue;
+    }
+    for (const run of block.runs) {
+      if (run.type === "image") {
+        if (found) return null;
+        found = run;
+      } else if (run.text.trim().length > 0) {
+        return null;
+      }
+    }
+  }
+  return found && found.widthPx >= pageWidthPx * 0.85 ? found : null;
+}
+
+// src/renderer/html.ts
+function styleToCss(s) {
+  const parts = [];
+  if (s.bold) parts.push("font-weight:bold");
+  if (s.italic) parts.push("font-style:italic");
+  const deco = [s.underline ? "underline" : "", s.strike ? "line-through" : ""].filter(Boolean);
+  if (deco.length) parts.push(`text-decoration:${deco.join(" ")}`);
+  if (s.vertAlign) {
+    parts.push(`vertical-align:${s.vertAlign}`);
+    parts.push("font-size:0.83em");
+  } else if (s.fontSize != null) {
+    parts.push(`font-size:${s.fontSize}pt`);
+  }
+  if (s.fontFamily) parts.push(`font-family:${s.fontFamily},sans-serif`);
+  if (s.color) parts.push(`color:#${s.color}`);
+  if (s.alignment) parts.push(`text-align:${s.alignment}`);
+  if (s.backgroundColor) parts.push(`background-color:#${s.backgroundColor}`);
+  if (s.highlight) parts.push(`background-color:${s.highlight}`);
+  return parts.join(";");
+}
+function renderRun(run, parent, skipLeadingTabs = false) {
+  const href = run.href;
+  let target = parent;
+  if (href) {
+    const a = document.createElement("a");
+    a.setAttribute("href", sanitizeHref(href));
+    a.target = "_blank";
+    a.rel = "noopener noreferrer";
+    parent.appendChild(a);
+    target = a;
+  }
+  if (run.type === "image") {
+    const img = document.createElement("img");
+    setImageSrc(img, run.src);
+    img.width = run.widthPx;
+    img.height = run.heightPx;
+    img.style.display = "inline-block";
+    img.style.maxWidth = "100%";
+    target.appendChild(img);
+    return;
+  }
+  const textRun = run;
+  if (textRun.deleted) {
+    if (!showRevisions) return;
+    const del = document.createElement("del");
+    del.style.cssText = "color:#c0392b";
+    target.appendChild(del);
+    target = del;
+  } else if (textRun.inserted && showRevisions) {
+    const ins = document.createElement("ins");
+    ins.style.cssText = "color:#1d6f42;text-decoration:underline";
+    target.appendChild(ins);
+    target = ins;
+  }
+  if (textRun.pageNumber) {
+    target.appendChild(document.createTextNode(String(currentPageNumber)));
+    return;
+  }
+  if (textRun.totalPages) {
+    const span = document.createElement("span");
+    span.dataset.ssdNumpages = "1";
+    span.textContent = "1";
+    target.appendChild(span);
+    return;
+  }
+  if (textRun.noteRef) {
+    const { type, number } = textRun.noteRef;
+    const prefix = type === "footnote" ? "fn" : "en";
+    const sup = document.createElement("sup");
+    sup.id = `${prefix}ref-${number}`;
+    const a = document.createElement("a");
+    a.setAttribute("href", `#${prefix}-${number}`);
+    a.textContent = String(number);
+    sup.appendChild(a);
+    target.appendChild(sup);
+    return;
+  }
+  for (let t = 0; !skipLeadingTabs && t < (textRun.tabs ?? 0); t++) {
+    const sp = document.createElement("span");
+    sp.style.cssText = "display:inline-block;min-width:2.5em";
+    target.appendChild(sp);
+  }
+  const css = styleToCss(textRun.style);
+  if (textRun.text) {
+    if (css || textRun.style.rtl) {
+      const span = document.createElement("span");
+      if (css) span.style.cssText = css;
+      if (textRun.style.rtl) span.dir = "rtl";
+      span.textContent = textRun.text;
+      target.appendChild(span);
+    } else {
+      target.appendChild(document.createTextNode(textRun.text));
+    }
+  }
+  if (textRun.lineBreak) target.appendChild(document.createElement("br"));
+}
+function renderNotes(doc, container, opts = { footnotes: true, endnotes: true }) {
+  const all = [];
+  if (opts.footnotes) all.push({ prefix: "fn", label: "Footnotes", notes: doc.footnotes });
+  if (opts.endnotes) all.push({ prefix: "en", label: "Endnotes", notes: doc.endnotes });
+  for (const { prefix, label, notes } of all) {
+    if (!notes || notes.length === 0) continue;
+    const section = document.createElement("section");
+    section.className = `ssd-${prefix === "fn" ? "footnotes" : "endnotes"}`;
+    const hr = document.createElement("hr");
+    section.appendChild(hr);
+    const heading = document.createElement("h2");
+    heading.textContent = label;
+    heading.style.cssText = "font-size:1em";
+    section.appendChild(heading);
+    const ol = document.createElement("ol");
+    for (const note of notes) {
+      const li = document.createElement("li");
+      li.id = `${prefix}-${note.number}`;
+      renderBlocks(note.blocks, li);
+      const back = document.createElement("a");
+      back.setAttribute("href", `#${prefix}ref-${note.number}`);
+      back.textContent = " \u21A9";
+      li.appendChild(back);
+      ol.appendChild(li);
+    }
+    section.appendChild(ol);
+    container.appendChild(section);
+  }
+}
+function sanitizeHref(href) {
+  const trimmed = href.trim();
+  if (/^(#|\/|\.|[^:]*$)/.test(trimmed)) return trimmed;
+  if (/^(https?:|mailto:|tel:)/i.test(trimmed)) return trimmed;
+  return "#";
+}
+function sanitizeImageSrc(src) {
+  const trimmed = src.trim();
+  if (/^data:image\//i.test(trimmed)) return trimmed;
+  if (/^https?:\/\//i.test(trimmed)) return trimmed;
+  if (/^(\/|\.|[^:]*$)/.test(trimmed)) return trimmed;
+  return "";
+}
+function setImageSrc(img, src) {
+  const safe = sanitizeImageSrc(src);
+  if (safe) img.src = safe;
+}
+var emptyLineEm = LINE_HEIGHT;
+var showRevisions = false;
+function ensureLineBox(el) {
+  if (!el.textContent && !el.querySelector("img")) {
+    el.style.minHeight = `${emptyLineEm}em`;
+  }
+}
+var inTableCell = false;
+var currentPageNumber = 0;
+var FOOTNOTE_SEPARATOR_H = 12;
+function footnoteNumbersIn(el) {
+  return Array.from(el.querySelectorAll('sup[id^="fnref-"]')).map((s) => parseInt(s.id.slice("fnref-".length), 10)).filter((n) => !Number.isNaN(n));
+}
+function buildFootnoteItem(fn) {
+  const item = document.createElement("div");
+  item.style.cssText = "display:flex;gap:6px;align-items:baseline";
+  const num = document.createElement("span");
+  num.id = `fn-${fn.number}`;
+  num.textContent = String(fn.number);
+  num.style.flex = "0 0 auto";
+  const content = document.createElement("div");
+  renderBlocks(fn.blocks, content);
+  const back = document.createElement("a");
+  back.setAttribute("href", `#fnref-${fn.number}`);
+  back.textContent = " \u21A9";
+  content.appendChild(back);
+  item.append(num, content);
+  return item;
+}
+function renderPageFootnotes(footnotes, pageDiv, numbers, pm) {
+  if (numbers.length === 0) return;
+  const box = document.createElement("div");
+  box.className = "ssd-footnotes";
+  box.style.cssText = `position:absolute;left:${pm.left}px;right:${pm.right}px;bottom:${pm.bottom}px;font-size:9pt;line-height:1.3`;
+  const sep = document.createElement("div");
+  sep.style.cssText = "border-top:1px solid #999;width:33%;margin-bottom:4px";
+  box.appendChild(sep);
+  for (const n of numbers) {
+    const fn = footnotes.find((f) => f.number === n);
+    if (fn) box.appendChild(buildFootnoteItem(fn));
+  }
+  pageDiv.appendChild(box);
+}
+function pickPart(doc, pageNum, def, first, even) {
+  if (doc.titlePg && pageNum === 1 && first) return first;
+  if (doc.evenAndOddHeaders && pageNum % 2 === 0 && even) return even;
+  return def;
+}
+function renderFooter(doc, pageDiv, pageNum, pm, footerPx) {
+  const footer = pickPart(doc, pageNum, doc.footer, doc.footerFirst, doc.footerEven);
+  if (!footer || footer.length === 0) return;
+  const prev = currentPageNumber;
+  currentPageNumber = pageNum;
+  const el = document.createElement("div");
+  el.className = "ssd-footer";
+  el.style.cssText = `position:absolute;left:${pm.left}px;right:${pm.right}px;bottom:${footerPx}px`;
+  renderBlocks(footer, el);
+  pageDiv.appendChild(el);
+  currentPageNumber = prev;
+}
+function fillTotalPages(container, total) {
+  container.querySelectorAll("[data-ssd-numpages]").forEach((el) => {
+    el.textContent = String(total);
+  });
+}
+function renderHeader(doc, pageDiv, pageNum, pm, headerPx) {
+  const header = pickPart(doc, pageNum, doc.header, doc.headerFirst, doc.headerEven);
+  if (!header || header.length === 0) return;
+  const prev = currentPageNumber;
+  currentPageNumber = pageNum;
+  const el = document.createElement("div");
+  el.className = "ssd-header";
+  el.style.cssText = `position:absolute;left:${pm.left}px;right:${pm.right}px;top:${headerPx}px`;
+  renderBlocks(header, el);
+  pageDiv.appendChild(el);
+  currentPageNumber = prev;
+}
+function paragraphCss(style, skipIndent = false) {
+  const mt = inTableCell ? 0 : style.spaceBefore ?? 0;
+  const mb = inTableCell ? 0 : style.spaceAfter ?? 0;
+  const lh = style.lineHeightPx != null ? `${style.lineHeightPx}px` : `${style.lineHeight ?? LINE_HEIGHT}`;
+  let css = `margin:${mt}px 0 ${mb}px;line-height:${lh}`;
+  if (!skipIndent) {
+    if (style.indentLeft) css += `;padding-left:${style.indentLeft}px`;
+    if (style.indentRight) css += `;padding-right:${style.indentRight}px`;
+    if (style.indentFirstLine) css += `;text-indent:${style.indentFirstLine}px`;
+    else if (style.indentHanging) css += `;text-indent:${-style.indentHanging}px`;
+  }
+  if (style.borderTop) css += `;border-top:${style.borderTop}`;
+  if (style.borderBottom) css += `;border-bottom:${style.borderBottom}`;
+  if (style.borderLeft) css += `;border-left:${style.borderLeft}`;
+  if (style.borderRight) css += `;border-right:${style.borderRight}`;
+  const inline = styleToCss(style);
+  if (inline) css += ";" + inline;
+  return css;
+}
+function renderParagraph(block) {
+  const p = document.createElement("p");
+  p.style.cssText = paragraphCss(block.style);
+  if (block.style.rtl) p.dir = "rtl";
+  const stops = block.style.tabStops;
+  const hasTabRun = block.runs.some((r) => r.type === "run" && (r.tabs ?? 0) > 0);
+  const alignStop = stops?.some((s) => s.val === "right" || s.val === "center" || s.val === "decimal");
+  if (hasTabRun && stops && alignStop) {
+    renderTabbedParagraph(block, p, stops);
+  } else {
+    for (const run of block.runs) renderRun(run, p);
+  }
+  ensureLineBox(p);
+  if (block.pageBreakBefore) p.dataset.ssdBreak = "1";
+  return p;
+}
+function renderTabbedParagraph(block, p, stops) {
+  p.style.display = "flex";
+  p.style.alignItems = "baseline";
+  p.style.width = "100%";
+  const segments = [];
+  const seps = [];
+  let stopIdx = 0;
+  let current = document.createElement("span");
+  current.style.cssText = "flex:0 1 auto;min-width:0";
+  segments.push(current);
+  for (const run of block.runs) {
+    let leadTabs = run.type === "run" ? run.tabs ?? 0 : 0;
+    while (leadTabs-- > 0) {
+      seps.push(stops[Math.min(stopIdx, stops.length - 1)]);
+      stopIdx++;
+      current = document.createElement("span");
+      current.style.cssText = "flex:0 1 auto;min-width:0";
+      segments.push(current);
+    }
+    renderRun(
+      run,
+      current,
+      /* skipLeadingTabs */
+      true
+    );
+  }
+  const last = segments[segments.length - 1];
+  if (segments.length > 1) last.style.cssText = "flex:0 0 auto;white-space:nowrap";
+  p.appendChild(segments[0]);
+  for (let i = 1; i < segments.length; i++) {
+    p.appendChild(makeLeader(seps[i - 1]));
+    p.appendChild(segments[i]);
+  }
+}
+function makeLeader(stop) {
+  const el = document.createElement("span");
+  const grows = stop.val === "right" || stop.val === "center" || stop.val === "decimal";
+  const border = stop.leader === "dot" ? "border-bottom:2px dotted currentColor" : stop.leader === "hyphen" ? "border-bottom:1px dashed currentColor" : stop.leader === "underscore" ? "border-bottom:1px solid currentColor" : "";
+  if (grows) {
+    el.style.cssText = `flex:1 1 0;margin:0 4px;align-self:flex-end;transform:translateY(-0.35em);${border}`;
+  } else {
+    el.style.cssText = "display:inline-block;flex:0 0 auto;min-width:2.5em";
+  }
+  return el;
+}
+function renderTable(block, container) {
+  const table = document.createElement("table");
+  table.style.borderCollapse = "collapse";
+  table.style.maxWidth = "100%";
+  if (block.columnWidths && block.columnWidths.length > 0) {
+    const total = block.columnWidths.reduce((a, b) => a + b, 0);
+    if (total > 0) {
+      table.style.tableLayout = "fixed";
+      table.style.width = `${total}px`;
+      if (block.align === "center") table.style.margin = "0 auto";
+      else if (block.align === "right") table.style.marginLeft = "auto";
+      const colgroup = document.createElement("colgroup");
+      for (const w of block.columnWidths) {
+        const col = document.createElement("col");
+        col.style.width = `${w}px`;
+        colgroup.appendChild(col);
+      }
+      table.appendChild(colgroup);
+    }
+  }
+  const pad = block.cellPadding;
+  for (const row of block.rows) {
+    const tr = document.createElement("tr");
+    if (row.heightPx) tr.style.height = `${row.heightPx}px`;
+    for (const cell of row.cells) {
+      const td = document.createElement("td");
+      if (cell.colSpan > 1) td.colSpan = cell.colSpan;
+      if (cell.rowSpan > 1) td.rowSpan = cell.rowSpan;
+      if (cell.backgroundColor) td.style.backgroundColor = `#${cell.backgroundColor}`;
+      if (cell.border) {
+        if (cell.border.top) td.style.borderTop = cell.border.top;
+        if (cell.border.right) td.style.borderRight = cell.border.right;
+        if (cell.border.bottom) td.style.borderBottom = cell.border.bottom;
+        if (cell.border.left) td.style.borderLeft = cell.border.left;
+      }
+      if (pad) td.style.padding = `${pad.top}px ${pad.right}px ${pad.bottom}px ${pad.left}px`;
+      td.style.verticalAlign = "top";
+      td.style.overflowWrap = "break-word";
+      td.style.wordBreak = "break-word";
+      const prev = inTableCell;
+      inTableCell = true;
+      renderBlocks(cell.blocks, td);
+      inTableCell = prev;
+      tr.appendChild(td);
+    }
+    table.appendChild(tr);
+  }
+  container.appendChild(table);
+}
+var LIST_STYLE = {
+  decimal: "decimal",
+  decimalZero: "decimal-leading-zero",
+  lowerLetter: "lower-alpha",
+  upperLetter: "upper-alpha",
+  lowerRoman: "lower-roman",
+  upperRoman: "upper-roman",
+  bullet: "disc",
+  none: "none"
+};
+function renderBlocks(blocks, container) {
+  let stack = [];
+  const closeLists = () => {
+    if (stack.length > 0) container.appendChild(stack[0].el);
+    stack = [];
+  };
+  for (const block of blocks) {
+    if (block.type === "paragraph" && block.list) {
+      const { numId, ordered, start, ilvl, format } = block.list;
+      if (stack.length > 0 && stack[0].numId !== numId) closeLists();
+      while (stack.length > ilvl + 1) stack.pop();
+      while (stack.length < ilvl + 1) {
+        const listEl = document.createElement(ordered ? "ol" : "ul");
+        if (ordered) listEl.start = start;
+        const styleType = LIST_STYLE[format];
+        if (styleType) listEl.style.listStyleType = styleType;
+        const indent = block.style.indentLeft ?? 24;
+        listEl.style.margin = "0";
+        listEl.style.paddingLeft = `${indent}px`;
+        const parent = stack[stack.length - 1];
+        if (parent) (parent.lastLi ?? parent.el).appendChild(listEl);
+        stack.push({ el: listEl, numId, lastLi: null });
+      }
+      const frame = stack[stack.length - 1];
+      const li = document.createElement("li");
+      li.style.cssText = paragraphCss(block.style, true);
+      for (const run of block.runs) renderRun(run, li);
+      frame.el.appendChild(li);
+      frame.lastLi = li;
+    } else {
+      closeLists();
+      if (block.type === "paragraph") {
+        container.appendChild(renderParagraph(block));
+      } else if (block.type === "table") {
+        renderTable(block, container);
+      }
+    }
+  }
+  closeLists();
+}
+function splitTableRows(table, availH) {
+  const rows = Array.from(table.rows);
+  let used = 0;
+  let splitAt = 0;
+  for (let i = 0; i < rows.length; i++) {
+    const rh = rows[i].offsetHeight;
+    if (used > 0 && used + rh > availH) break;
+    used += rh;
+    splitAt = i + 1;
+  }
+  if (splitAt === 0 || splitAt >= rows.length) return null;
+  const rest = table.cloneNode(false);
+  for (let i = splitAt; i < rows.length; i++) rest.appendChild(rows[i]);
+  return rest;
+}
+function pageBoxStyle(pw, ph, pm, extra = []) {
+  return [
+    "position:relative",
+    "box-sizing:border-box",
+    "background-color:#fff",
+    "margin:0 auto 16px",
+    "box-shadow:0 2px 12px rgba(0,0,0,.25)",
+    "flex-shrink:0",
+    `width:${pw}px`,
+    `min-height:${ph}px`,
+    `padding:${pm.top}px ${pm.right}px ${pm.bottom}px ${pm.left}px`,
+    ...extra
+  ].join(";");
+}
+function renderPlainPaginated(doc, container, pw, ph, pm, pageOffset = 0) {
+  const contentW = pw - pm.left - pm.right;
+  const contentH = ph - pm.top - pm.bottom;
+  const stage = document.createElement("div");
+  stage.className = "ssd-page";
+  stage.style.cssText = `position:absolute;left:-9999px;top:0;visibility:hidden;width:${contentW}px;padding:0;margin:0;min-height:0;box-shadow:none;background:none`;
+  container.appendChild(stage);
+  renderBlocks(doc.blocks, stage);
+  const children = Array.from(stage.children);
+  const tops = children.map((c) => c.offsetTop);
+  const stageH = stage.scrollHeight;
+  const heights = children.map((_, i) => (i + 1 < children.length ? tops[i + 1] : stageH) - tops[i]);
+  const footnotes = doc.footnotes ?? [];
+  const footnoteH = {};
+  for (const fn of footnotes) {
+    const item = buildFootnoteItem(fn);
+    item.style.position = "absolute";
+    item.style.visibility = "hidden";
+    item.style.width = `${contentW}px`;
+    stage.appendChild(item);
+    footnoteH[fn.number] = item.offsetHeight;
+    stage.removeChild(item);
+  }
+  const pages = [];
+  const pageFootnotes = [];
+  let pageDiv;
+  let used = 0;
+  let reserve = 0;
+  let pageHasFn = false;
+  const newPage = () => {
+    const div = document.createElement("div");
+    div.className = "ssd-page";
+    div.style.cssText = pageBoxStyle(pw, ph, pm);
+    container.appendChild(div);
+    pages.push(div);
+    pageFootnotes.push([]);
+    used = 0;
+    reserve = 0;
+    pageHasFn = false;
+    return div;
+  };
+  const fnReserve = (nums, hasFn) => nums.length === 0 ? 0 : (hasFn ? 0 : FOOTNOTE_SEPARATOR_H) + nums.reduce((a, n) => a + (footnoteH[n] ?? 0), 0);
+  const recordFootnotes = (nums, add) => {
+    if (nums.length === 0) return;
+    pageFootnotes[pages.length - 1].push(...nums);
+    reserve += add;
+    pageHasFn = true;
+  };
+  pageDiv = newPage();
+  for (let i = 0; i < children.length; i++) {
+    const child = children[i];
+    const forced = child.dataset.ssdBreak === "1";
+    if (child.tagName === "TABLE") {
+      if (forced && used > 0) pageDiv = newPage();
+      let table = child;
+      for (; ; ) {
+        pageDiv.appendChild(table);
+        const th = table.offsetHeight;
+        if (used + th <= contentH - reserve) {
+          used += th;
+          break;
+        }
+        const rest = splitTableRows(table, contentH - reserve - used);
+        if (!rest) {
+          if (used === 0) {
+            used += th;
+            break;
+          }
+          pageDiv.removeChild(table);
+          pageDiv = newPage();
+          continue;
+        }
+        pageDiv = newPage();
+        table = rest;
+      }
+      const refs2 = footnoteNumbersIn(table);
+      recordFootnotes(refs2, fnReserve(refs2, pageHasFn));
+      continue;
+    }
+    const h = heights[i];
+    const refs = footnoteNumbersIn(child);
+    let add = fnReserve(refs, pageHasFn);
+    if (forced && used > 0 || used > 0 && used + h > contentH - reserve - add) {
+      pageDiv = newPage();
+      add = fnReserve(refs, false);
+    }
+    pageDiv.appendChild(child);
+    used += h;
+    recordFootnotes(refs, add);
+  }
+  stage.remove();
+  for (let i = pages.length - 1; i >= 0; i--) {
+    const hasFn = pageFootnotes[i].length > 0;
+    const hasContent = (pages[i].textContent ?? "").trim().length > 0 || !!pages[i].querySelector("img,table");
+    if (!hasFn && !hasContent) {
+      pages[i].remove();
+      pages.splice(i, 1);
+      pageFootnotes.splice(i, 1);
+    }
+  }
+  pages.forEach((page, i) => renderPageFootnotes(footnotes, page, pageFootnotes[i], pm));
+  if (doc.endnotes && doc.endnotes.length > 0) {
+    const endHost = document.createElement("div");
+    renderNotes(doc, endHost, { endnotes: true });
+    if (endHost.childNodes.length > 0) {
+      const div = newPage();
+      while (endHost.firstChild) div.appendChild(endHost.firstChild);
+    }
+  }
+  const footerPx = doc.pageSize?.footerPx ?? Math.round(pm.bottom / 2);
+  pages.forEach((page, i) => renderFooter(doc, page, pageOffset + i + 1, pm, footerPx));
+  const headerPx = doc.pageSize?.headerPx ?? Math.round(pm.top / 2);
+  pages.forEach((page, i) => renderHeader(doc, page, pageOffset + i + 1, pm, headerPx));
+  fillTotalPages(container, container.querySelectorAll(".ssd-page").length);
+}
+function render(doc, container, options = {}) {
+  showRevisions = options.showRevisions ?? false;
+  const hasPageBg = doc.blocks.some(
+    (b) => b.type === "paragraph" && extractPageBackground(b) !== null
+  );
+  const ps = doc.pageSize;
+  if (!ps || ps.widthPx === 0 || ps.heightPx === 0) {
+    emptyLineEm = hasPageBg ? EMPTY_LINE_EM : LINE_HEIGHT;
+    renderBlocks(doc.blocks, container);
+    renderNotes(doc, container);
+    fillTotalPages(container, 1);
+    return;
+  }
+  if (doc.sections && doc.sections.length > 1) {
+    renderSections(doc, container, hasPageBg);
+    return;
+  }
+  emptyLineEm = hasPageBg ? EMPTY_LINE_EM : LINE_HEIGHT;
+  if (!hasPageBg) {
+    renderPlainPaginated(doc, container, ps.widthPx, ps.heightPx, ps.marginPx);
+    return;
+  }
+  renderPageBgPaginated(doc, container);
+}
+function renderSections(doc, container, docHasPageBg) {
+  const sections = doc.sections;
+  const lastIdx = sections.length - 1;
+  if (!docHasPageBg) {
+    emptyLineEm = LINE_HEIGHT;
+    sections.forEach((section, i) => {
+      const sp = section.pageSize;
+      const subDoc = {
+        blocks: section.blocks,
+        pageSize: sp,
+        footnotes: doc.footnotes,
+        endnotes: i === lastIdx ? doc.endnotes : void 0,
+        footer: section.footer ?? doc.footer,
+        header: section.header ?? doc.header
+      };
+      const pageOffset = container.querySelectorAll(".ssd-page").length;
+      renderPlainPaginated(subDoc, container, sp.widthPx, sp.heightPx, sp.marginPx, pageOffset);
+    });
+    return;
+  }
+  for (const section of sections) {
+    const sp = section.pageSize;
+    const sectionHasBg = section.blocks.some(
+      (b) => b.type === "paragraph" && extractPageBackground(b) !== null
+    );
+    emptyLineEm = sectionHasBg ? EMPTY_LINE_EM : LINE_HEIGHT;
+    const subDoc = {
+      blocks: section.blocks,
+      pageSize: sp,
+      footer: section.footer ?? doc.footer,
+      header: section.header ?? doc.header
+    };
+    if (sectionHasBg) {
+      renderPageBgPaginated(subDoc, container);
+    } else {
+      const pageOffset = container.querySelectorAll(".ssd-page").length;
+      renderPlainPaginated(subDoc, container, sp.widthPx, sp.heightPx, sp.marginPx, pageOffset);
+    }
+  }
+  appendNotesPage(doc, container);
+  fillTotalPages(container, container.querySelectorAll(".ssd-page").length);
+}
+function appendNotesPage(doc, container) {
+  const host = document.createElement("div");
+  renderNotes(doc, host);
+  if (host.childNodes.length === 0) return;
+  const ps = doc.pageSize;
+  const pm = ps.marginPx;
+  const div = document.createElement("div");
+  div.className = "ssd-page";
+  div.style.cssText = [
+    "position:relative",
+    "box-sizing:border-box",
+    "background-color:#fff",
+    "margin:0 auto 16px",
+    "box-shadow:0 2px 12px rgba(0,0,0,.25)",
+    `width:${ps.widthPx}px`,
+    `min-height:${ps.heightPx}px`,
+    `padding:${pm.top}px ${pm.right}px ${pm.bottom}px ${pm.left}px`
+  ].join(";");
+  while (host.firstChild) div.appendChild(host.firstChild);
+  container.appendChild(div);
+}
+function renderPageBgPaginated(doc, container) {
+  const hasPageBg = true;
+  const ps = doc.pageSize;
+  const pw = ps.widthPx;
+  const ph = ps.heightPx;
+  const pm = ps.marginPx;
+  const contentW = pw - pm.left - pm.right;
+  const contentH = ph - pm.top - pm.bottom;
+  const toFlow = (block) => hasPageBg && block.type === "paragraph" ? flowOnly(block, pw, ph) : block;
+  const measureDiv = document.createElement("div");
+  measureDiv.className = "ssd-page";
+  measureDiv.style.cssText = `position:fixed;top:-9999px;left:-9999px;visibility:hidden;pointer-events:none;width:${contentW}px;padding:0;margin:0;min-height:0;box-shadow:none;background:none`;
+  container.appendChild(measureDiv);
+  const blockHeight = new Array(doc.blocks.length).fill(0);
+  for (let i = 0; i < doc.blocks.length; i++) {
+    const toMeasure = toFlow(doc.blocks[i]);
+    if (!toMeasure) continue;
+    const el = document.createElement("div");
+    renderBlocks([toMeasure], el);
+    measureDiv.appendChild(el);
+    blockHeight[i] = el.offsetHeight;
+    measureDiv.removeChild(el);
+  }
+  container.removeChild(measureDiv);
+  const n = doc.blocks.length;
+  const sectionStart = new Array(n).fill(false);
+  if (hasPageBg) {
+    for (let i = 0; i < n; i++) {
+      let heading = isHeadingBlock(doc.blocks[i]);
+      if (heading && i > 0 && sectionStart[i - 1] && isIconOnly(doc.blocks[i - 1])) {
+        heading = false;
+      }
+      const iconLead = isIconOnly(doc.blocks[i]) && i + 1 < n && isHeadingBlock(doc.blocks[i + 1]);
+      sectionStart[i] = heading || iconLead;
+    }
+  }
+  const forcesBreak = (i) => sectionStart[i] || doc.blocks[i].type === "paragraph" && !!doc.blocks[i].pageBreakBefore;
+  const blockPage = new Array(n).fill(0);
+  let page = 0;
+  let usedOnPage = 0;
+  for (let i = 0; i < n; i++) {
+    const h = blockHeight[i];
+    if (forcesBreak(i) && usedOnPage > 0 || usedOnPage > 0 && usedOnPage + h > contentH) {
+      page++;
+      usedOnPage = 0;
+    }
+    blockPage[i] = page;
+    usedOnPage += h;
+  }
+  let totalPages = page + 1;
+  const distinctBgs = [];
+  for (let i = 0; i < doc.blocks.length; i++) {
+    const block = doc.blocks[i];
+    if (block.type !== "paragraph") continue;
+    const bg = extractPageBackground(block);
+    if (!bg) continue;
+    const last = distinctBgs[distinctBgs.length - 1];
+    if (!last || last.src !== bg.src) distinctBgs.push(bg);
+  }
+  const pageBg = new Array(totalPages).fill(null);
+  const keepIfEmpty = new Array(totalPages).fill(false);
+  for (let k = 0; k < distinctBgs.length; k++) {
+    const startPage = Math.min(k, totalPages - 1);
+    const end = k + 1 < distinctBgs.length ? Math.min(k + 1, totalPages) : totalPages;
+    if (k === 0) keepIfEmpty[startPage] = true;
+    for (let p = startPage; p < end; p++) pageBg[p] = distinctBgs[k];
+  }
+  const pageBlocks = Array.from({ length: totalPages }, () => []);
+  const pageWatermarks = Array.from({ length: totalPages }, () => []);
+  for (let i = 0; i < doc.blocks.length; i++) {
+    const block = doc.blocks[i];
+    const renderable = toFlow(block);
+    if (renderable) pageBlocks[blockPage[i]].push(renderable);
+    if (hasPageBg) for (const wm of watermarksOf(block, pw, ph)) pageWatermarks[blockPage[i]].push(wm);
+  }
+  const wmForBg = /* @__PURE__ */ new Map();
+  for (let p = 0; p < totalPages; p++) {
+    const bgSrc = pageBg[p]?.src ?? "";
+    for (const wm of pageWatermarks[p]) if (!wmForBg.has(bgSrc)) wmForBg.set(bgSrc, wm);
+  }
+  for (let p = 0; p < totalPages; p++) {
+    const wm = wmForBg.get(pageBg[p]?.src ?? "");
+    pageWatermarks[p] = wm ? [wm] : [];
+    if (wm) pageBg[p] = null;
+  }
+  const notePage = document.createElement("div");
+  renderNotes(doc, notePage);
+  if (notePage.childNodes.length > 0) {
+    pageBlocks.push([]);
+    pageWatermarks.push([]);
+    pageBg.push(null);
+    totalPages++;
+  }
+  const pageBoxCss = (extra = []) => [
+    "position:relative",
+    "box-sizing:border-box",
+    "background-color:#fff",
+    "margin:0 auto 16px",
+    "box-shadow:0 2px 12px rgba(0,0,0,.25)",
+    `width:${pw}px`,
+    `min-height:${ph}px`,
+    ...extra
+  ].join(";");
+  const bgH = `${ph}px`;
+  for (let p = 0; p < totalPages; p++) {
+    const blocks = pageBlocks[p];
+    const isNotePage = p === totalPages - 1 && notePage.childNodes.length > 0 && blocks.length === 0;
+    const keepEmptyCover = keepIfEmpty[p] && (pageBg[p] !== null || pageWatermarks[p].length > 0);
+    if (!isNotePage && !blocks.some(isBlockVisible) && !keepEmptyCover) continue;
+    const div = document.createElement("div");
+    div.className = "ssd-page";
+    if (isNotePage) {
+      div.style.cssText = pageBoxCss([`padding:${pm.top}px ${pm.right}px ${pm.bottom}px ${pm.left}px`]);
+      while (notePage.firstChild) div.appendChild(notePage.firstChild);
+      container.appendChild(div);
+      continue;
+    }
+    const fullImg = hasPageBg ? fullPageImage(blocks, pw) : null;
+    if (fullImg) {
+      div.style.cssText = [
+        "position:relative",
+        "box-sizing:border-box",
+        `width:${pw}px`,
+        `height:${ph}px`,
+        `min-height:${ph}px`,
+        "flex-shrink:0",
+        "margin:0 auto 16px",
+        "overflow:hidden",
+        "box-shadow:0 2px 12px rgba(0,0,0,.25)"
+      ].join(";");
+      const img = document.createElement("img");
+      setImageSrc(img, fullImg.src);
+      img.style.cssText = "position:absolute;top:0;left:0;width:100%;height:100%;object-fit:cover";
+      div.appendChild(img);
+      container.appendChild(div);
+      continue;
+    }
+    const bgImg = pageBg[p];
+    const extra = [
+      "background-repeat:no-repeat",
+      "background-position:top center",
+      `background-size:100% ${bgH}`,
+      `padding:${pm.top}px ${pm.right}px ${pm.bottom}px ${pm.left}px`
+    ];
+    const bgSafe = bgImg ? sanitizeImageSrc(bgImg.src) : "";
+    if (bgSafe) extra.push(`background-image:url('${bgSafe}')`);
+    div.style.cssText = pageBoxCss(extra);
+    for (const wm of pageWatermarks[p]) {
+      const img = document.createElement("img");
+      setImageSrc(img, wm.src);
+      img.style.cssText = "position:absolute;top:0;left:0;width:100%;height:100%;object-fit:fill;z-index:0;pointer-events:none";
+      div.appendChild(img);
+    }
+    const content = document.createElement("div");
+    content.style.cssText = "position:relative;z-index:1";
+    renderBlocks(blocks, content);
+    div.appendChild(content);
+    container.appendChild(div);
+  }
+  fillTotalPages(container, container.querySelectorAll(".ssd-page").length);
+}
+
+// src/index.ts
+function parsePageSize(xml) {
+  const twipsToPx2 = (s) => Math.round(parseFloat(s) * 96 / 1440);
+  const lastSect = xml.lastIndexOf("<w:sectPr");
+  const scope = lastSect !== -1 ? xml.slice(lastSect) : xml;
+  const pgSz = /<w:pgSz\b([^/]*)\/?>/.exec(scope) ?? /<w:pgSz\b([^/]*)\/?>/.exec(xml);
+  if (!pgSz) return void 0;
+  const attrs = pgSz[1];
+  const w = /\bw:w="([\d.]+)"/.exec(attrs)?.[1];
+  const h = /\bw:h="([\d.]+)"/.exec(attrs)?.[1];
+  if (!w || !h) return void 0;
+  const pgMar = /<w:pgMar\b([^/]*)\/?>/.exec(scope) ?? /<w:pgMar\b([^/]*)\/?>/.exec(xml);
+  const ma = pgMar?.[1] ?? "";
+  const top = /\bw:top="([\d.]+)"/.exec(ma)?.[1] ?? "1440";
+  const right = /\bw:right="([\d.]+)"/.exec(ma)?.[1] ?? "1440";
+  const bottom = /\bw:bottom="([\d.]+)"/.exec(ma)?.[1] ?? "1440";
+  const left = /\bw:left="([\d.]+)"/.exec(ma)?.[1] ?? "1440";
+  const footer = /\bw:footer="([\d.]+)"/.exec(ma)?.[1];
+  const header = /\bw:header="([\d.]+)"/.exec(ma)?.[1];
+  return {
+    widthPx: twipsToPx2(w),
+    heightPx: twipsToPx2(h),
+    marginPx: {
+      top: twipsToPx2(top),
+      right: twipsToPx2(right),
+      bottom: twipsToPx2(bottom),
+      left: twipsToPx2(left)
+    },
+    ...footer ? { footerPx: twipsToPx2(footer) } : {},
+    ...header ? { headerPx: twipsToPx2(header) } : {}
+  };
+}
+async function readEntry(zip, path, required) {
+  const entry = zip.file(path);
+  if (!entry) {
+    if (required) throw new DocxParseError(`Missing required entry: ${path}`, "MISSING_ENTRY");
+    return null;
+  }
+  return entry.async("string");
+}
+async function parse(buffer) {
+  let zip;
+  try {
+    zip = await JSZip.loadAsync(buffer);
+  } catch {
+    throw new DocxParseError("Failed to load zip archive", "INVALID_ZIP");
+  }
+  const [documentXml, stylesXml, relsXml, numberingXml, footnotesXml, endnotesXml, settingsXml] = await Promise.all([
+    readEntry(zip, "word/document.xml", true),
+    readEntry(zip, "word/styles.xml", true),
+    readEntry(zip, "word/_rels/document.xml.rels", false),
+    readEntry(zip, "word/numbering.xml", false),
+    readEntry(zip, "word/footnotes.xml", false),
+    readEntry(zip, "word/endnotes.xml", false),
+    readEntry(zip, "word/settings.xml", false)
+  ]);
+  const relationshipMap = relsXml ? parseRelationships(relsXml) : {};
+  const { styleMap, docDefaults, tableBorderMap } = parseStyles(stylesXml);
+  const { abstractNumMap, numMap } = numberingXml ? parseNumbering(numberingXml) : emptyNumbering();
+  const ctx = {
+    styleMap,
+    docDefaults,
+    tableBorderMap,
+    abstractNumMap,
+    numMap,
+    relationshipMap,
+    zip,
+    footnoteRefs: [],
+    endnoteRefs: []
+  };
+  const blocks = await parseDocument(documentXml, ctx);
+  const footnotes = await resolveNotes(footnotesXml, "footnote", ctx.footnoteRefs, ctx);
+  const endnotes = await resolveNotes(endnotesXml, "endnote", ctx.endnoteRefs, ctx);
+  const footer = await resolveFooter(documentXml, relationshipMap, zip, ctx);
+  const header = await resolveHeader(documentXml, relationshipMap, zip, ctx);
+  const headerFirst = await resolveHeader(documentXml, relationshipMap, zip, ctx, "first");
+  const headerEven = await resolveHeader(documentXml, relationshipMap, zip, ctx, "even");
+  const footerFirst = await resolveFooter(documentXml, relationshipMap, zip, ctx, "first");
+  const footerEven = await resolveFooter(documentXml, relationshipMap, zip, ctx, "even");
+  const bodySectScope = documentXml.slice(documentXml.lastIndexOf("<w:sectPr"));
+  const titlePg = /<w:titlePg\b[^>]*\/?>/.test(bodySectScope) && !/<w:titlePg\b[^>]*w:val="(?:0|false|off)"/.test(bodySectScope);
+  const evenAndOddHeaders = !!settingsXml && /<w:evenAndOddHeaders\b[^>]*\/?>/.test(settingsXml) && !/<w:evenAndOddHeaders\b[^>]*w:val="(?:0|false|off)"/.test(settingsXml);
+  const pageSize = parsePageSize(documentXml);
+  const resolveRef = (rId, kind) => resolveRid(rId, relationshipMap, zip, ctx, kind === "header" ? parseHeaderXml : parseFooterXml);
+  const sections = pageSize ? await buildSections(blocks, pageSize, bodySectPrRefs(documentXml), resolveRef, header, footer) : [];
+  return {
+    blocks,
+    pageSize,
+    ...footnotes.length ? { footnotes } : {},
+    ...endnotes.length ? { endnotes } : {},
+    ...footer && footer.length ? { footer } : {},
+    ...header && header.length ? { header } : {},
+    ...headerFirst && headerFirst.length ? { headerFirst } : {},
+    ...headerEven && headerEven.length ? { headerEven } : {},
+    ...footerFirst && footerFirst.length ? { footerFirst } : {},
+    ...footerEven && footerEven.length ? { footerEven } : {},
+    ...titlePg ? { titlePg } : {},
+    ...evenAndOddHeaders ? { evenAndOddHeaders } : {},
+    ...sections.length > 1 ? { sections } : {}
+  };
+}
+async function buildSections(blocks, bodyPageSize, bodyRefs, resolveRef, docHeader, docFooter) {
+  const raw = [];
+  let cur = [];
+  for (const b of blocks) {
+    cur.push(b);
+    const pb = b.type === "paragraph" ? b : void 0;
+    const tagged = pb?.sectionPageSize;
+    if (tagged) {
+      raw.push({ blocks: cur, pageSize: tagged, refs: pb.sectionRefs ?? {} });
+      delete pb.sectionPageSize;
+      delete pb.sectionRefs;
+      cur = [];
+    }
+  }
+  if (cur.length) raw.push({ blocks: cur, pageSize: bodyPageSize, refs: bodyRefs });
+  const sections = [];
+  let carriedHeader = docHeader;
+  let carriedFooter = docFooter;
+  for (const s of raw) {
+    if (s.refs.headerRId) carriedHeader = await resolveRef(s.refs.headerRId, "header") ?? carriedHeader;
+    if (s.refs.footerRId) carriedFooter = await resolveRef(s.refs.footerRId, "footer") ?? carriedFooter;
+    const header = carriedHeader;
+    const footer = carriedFooter;
+    sections.push({
+      blocks: s.blocks,
+      pageSize: s.pageSize,
+      ...header && header.length ? { header } : {},
+      ...footer && footer.length ? { footer } : {}
+    });
+  }
+  return sections;
+}
+function bodySectPrRefs(documentXml) {
+  const lastSect = documentXml.lastIndexOf("<w:sectPr");
+  if (lastSect === -1) return {};
+  const end = documentXml.indexOf("</w:sectPr>", lastSect);
+  const scope = end !== -1 ? documentXml.slice(lastSect, end) : documentXml.slice(lastSect);
+  return {
+    ...defaultRefRId(scope, "header") ? { headerRId: defaultRefRId(scope, "header") } : {},
+    ...defaultRefRId(scope, "footer") ? { footerRId: defaultRefRId(scope, "footer") } : {}
+  };
+}
+function defaultRefRId(scope, kind) {
+  const re = new RegExp(`<w:${kind}Reference\\b[^>]*>`, "g");
+  let m;
+  while ((m = re.exec(scope)) !== null) {
+    if (/w:type="default"/.test(m[0])) return /r:id="([^"]+)"/.exec(m[0])?.[1];
+  }
+  return void 0;
+}
+async function resolveFooter(documentXml, relationshipMap, zip, ctx, type = "default") {
+  return resolvePart(documentXml, relationshipMap, zip, ctx, "footer", parseFooterXml, type);
+}
+async function resolveHeader(documentXml, relationshipMap, zip, ctx, type = "default") {
+  return resolvePart(documentXml, relationshipMap, zip, ctx, "header", parseHeaderXml, type);
+}
+async function resolvePart(documentXml, relationshipMap, zip, ctx, kind, parseXml, type = "default") {
+  const ref = new RegExp(`<w:${kind}Reference\\b[^>]*>`, "g");
+  let m;
+  let rId;
+  while ((m = ref.exec(documentXml)) !== null) {
+    const tag = m[0];
+    if (!new RegExp(`w:type="${type}"`).test(tag)) continue;
+    rId = /r:id="([^"]+)"/.exec(tag)?.[1];
+    break;
+  }
+  return resolveRid(rId, relationshipMap, zip, ctx, parseXml);
+}
+async function resolveRid(rId, relationshipMap, zip, ctx, parseXml) {
+  if (!rId || !relationshipMap[rId]) return void 0;
+  const xml = await readEntry(zip, `word/${relationshipMap[rId].target}`, false);
+  return xml ? parseXml(xml, ctx) : void 0;
+}
+async function resolveNotes(xml, kind, refIds, ctx) {
+  if (!xml || refIds.length === 0) return [];
+  const map = await parseNotesXml(xml, kind, ctx);
+  const entries = [];
+  refIds.forEach((id, i) => {
+    const noteBlocks = map.get(id);
+    if (noteBlocks) entries.push({ number: i + 1, blocks: noteBlocks });
+  });
+  return entries;
+}
+function render2(doc, container, options) {
+  render(doc, container, options);
+}
+export {
+  DocxParseError,
+  parse,
+  render2 as render
+};