@shadow-garden/bapbong-docx 0.1.0

package/dist/index.js

@@ -0,0 +1,1802 @@
+// packages/docx/src/lib/docx.ts
+import JSZip from "jszip";
+import {
+  commentSchema,
+  schema
+} from "@shadow-garden/bapbong-model";
+
+// packages/docx/src/lib/ooxml.ts
+import { XMLParser } from "fast-xml-parser";
+var parser = new XMLParser({
+  ignoreAttributes: false,
+  attributeNamePrefix: "@_",
+  preserveOrder: true,
+  // Keep significant whitespace in <w:t> (e.g. xml:space="preserve" "Hello ").
+  trimValues: false,
+  // Text is text — never strnum it. The default (true) mangles document
+  // content: "100.000" → 100, "00" → 0, "1." → 1 — Word splits numbers like
+  // "1.500.000" across runs (rsid), and each fragment got destroyed.
+  parseTagValue: false
+});
+function buildNode(entry) {
+  const name = Object.keys(entry).find((k) => k !== ":@") ?? "";
+  const attrs = {};
+  const rawAttrs = entry[":@"];
+  if (rawAttrs) {
+    for (const [k, v] of Object.entries(rawAttrs)) {
+      attrs[k.startsWith("@_") ? k.slice(2) : k] = v == null ? "" : String(v);
+    }
+  }
+  const raw = entry[name];
+  const rawChildren = Array.isArray(raw) ? raw : [];
+  const children2 = [];
+  let text = "";
+  for (const c of rawChildren) {
+    if (Object.prototype.hasOwnProperty.call(c, "#text")) {
+      text += String(c["#text"] ?? "");
+    } else {
+      children2.push(buildNode(c));
+    }
+  }
+  return { name, attrs, children: children2, text };
+}
+function parseXml(xml) {
+  const top = parser.parse(xml);
+  const children2 = top.filter((e) => {
+    const key = Object.keys(e).find((k) => k !== ":@");
+    return !!key && key !== "#text" && !key.startsWith("?");
+  }).map(buildNode);
+  return { name: "#root", attrs: {}, children: children2, text: "" };
+}
+function child(node, name) {
+  return node?.children.find((c) => c.name === name);
+}
+function children(node, name) {
+  return node ? node.children.filter((c) => c.name === name) : [];
+}
+function attrOf(node, name) {
+  return node?.attrs[name];
+}
+function findDescendant(node, name) {
+  if (!node) return void 0;
+  for (const c of node.children) {
+    if (c.name === name) return c;
+    const found = findDescendant(c, name);
+    if (found) return found;
+  }
+  return void 0;
+}
+var OFF = /* @__PURE__ */ new Set(["false", "0", "off"]);
+function toggle(el) {
+  if (!el) return void 0;
+  const v = attrOf(el, "w:val");
+  return v === void 0 ? true : !OFF.has(v.toLowerCase());
+}
+function underlineToggle(el) {
+  if (!el) return void 0;
+  const v = attrOf(el, "w:val");
+  if (v === void 0) return true;
+  const lower = v.toLowerCase();
+  return lower !== "none" && !OFF.has(lower);
+}
+var HIGHLIGHT_COLORS = {
+  yellow: "#FFFF00",
+  green: "#00FF00",
+  cyan: "#00FFFF",
+  magenta: "#FF00FF",
+  blue: "#0000FF",
+  red: "#FF0000",
+  darkBlue: "#000080",
+  darkCyan: "#008080",
+  darkGreen: "#008000",
+  darkMagenta: "#800080",
+  darkRed: "#800000",
+  darkYellow: "#808000",
+  darkGray: "#808080",
+  lightGray: "#C0C0C0",
+  black: "#000000",
+  white: "#FFFFFF"
+};
+function normalizeHex(v) {
+  if (!v || v.toLowerCase() === "auto") return void 0;
+  return v.startsWith("#") ? v.toUpperCase() : `#${v.toUpperCase()}`;
+}
+function parseRunProps(rPr, resolveTheme) {
+  if (!rPr) return {};
+  const props = {};
+  const b = toggle(child(rPr, "w:b"));
+  if (b !== void 0) props.bold = b;
+  const i = toggle(child(rPr, "w:i"));
+  if (i !== void 0) props.italic = i;
+  const u = underlineToggle(child(rPr, "w:u"));
+  if (u !== void 0) props.underline = u;
+  const s = toggle(child(rPr, "w:strike"));
+  if (s !== void 0) props.strike = s;
+  const colorEl = child(rPr, "w:color");
+  const colorVal = attrOf(colorEl, "w:val");
+  if (colorVal && colorVal.toLowerCase() !== "auto") {
+    props.color = colorVal.startsWith("#") ? colorVal.toUpperCase() : `#${colorVal.toUpperCase()}`;
+  } else if (resolveTheme) {
+    const themeColor = attrOf(colorEl, "w:themeColor");
+    if (themeColor) {
+      const hex = resolveTheme(
+        themeColor,
+        attrOf(colorEl, "w:themeTint"),
+        attrOf(colorEl, "w:themeShade")
+      );
+      if (hex) props.color = hex;
+    }
+  }
+  const sz = attrOf(child(rPr, "w:sz"), "w:val");
+  if (sz !== void 0) {
+    const halfPoints = Number(sz);
+    if (!Number.isNaN(halfPoints)) props.sizePt = halfPoints / 2;
+  }
+  const rFonts = child(rPr, "w:rFonts");
+  const family = attrOf(rFonts, "w:ascii") ?? attrOf(rFonts, "w:hAnsi");
+  if (family) props.fontFamily = family;
+  const va = attrOf(child(rPr, "w:vertAlign"), "w:val");
+  if (va === "superscript") props.vertAlign = "super";
+  else if (va === "subscript") props.vertAlign = "sub";
+  const hl = attrOf(child(rPr, "w:highlight"), "w:val");
+  if (hl && hl !== "none") {
+    props.highlight = HIGHLIGHT_COLORS[hl] ?? normalizeHex(hl);
+  } else {
+    const hex = normalizeHex(attrOf(child(rPr, "w:shd"), "w:fill"));
+    if (hex) props.highlight = hex;
+  }
+  return props;
+}
+function mergeRunProps(base, over) {
+  return { ...base, ...over };
+}
+
+// packages/docx/src/lib/styles.ts
+var EMPTY = {};
+function buildStyleRegistry(stylesRoot, resolveTheme) {
+  const stylesEl = child(stylesRoot, "w:styles");
+  const rPrDefault = child(child(child(stylesEl, "w:docDefaults"), "w:rPrDefault"), "w:rPr");
+  const docDefaults = parseRunProps(rPrDefault, resolveTheme);
+  const docDefaultsPPr = child(child(child(stylesEl, "w:docDefaults"), "w:pPrDefault"), "w:pPr");
+  const defs = /* @__PURE__ */ new Map();
+  for (const style of children(stylesEl, "w:style")) {
+    const id = attrOf(style, "w:styleId");
+    if (id === void 0) continue;
+    defs.set(id, {
+      basedOn: attrOf(child(style, "w:basedOn"), "w:val"),
+      rPr: parseRunProps(child(style, "w:rPr"), resolveTheme),
+      pPr: child(style, "w:pPr"),
+      tblBorders: child(child(style, "w:tblPr"), "w:tblBorders")
+    });
+  }
+  function resolve(styleId, seen) {
+    if (!styleId || seen.has(styleId)) return EMPTY;
+    const def = defs.get(styleId);
+    if (!def) return EMPTY;
+    seen.add(styleId);
+    const base = def.basedOn ? resolve(def.basedOn, seen) : EMPTY;
+    return mergeRunProps(base, def.rPr);
+  }
+  function resolvePPr(styleId, seen) {
+    if (!styleId || seen.has(styleId)) return [];
+    const def = defs.get(styleId);
+    if (!def) return [];
+    seen.add(styleId);
+    const base = def.basedOn ? resolvePPr(def.basedOn, seen) : [];
+    return def.pPr ? [...base, def.pPr] : base;
+  }
+  function resolveTblBorders(styleId, seen) {
+    if (!styleId || seen.has(styleId)) return void 0;
+    const def = defs.get(styleId);
+    if (!def) return void 0;
+    seen.add(styleId);
+    return def.tblBorders ?? resolveTblBorders(def.basedOn, seen);
+  }
+  return {
+    docDefaults,
+    docDefaultsPPr,
+    resolveStyle: (styleId) => resolve(styleId, /* @__PURE__ */ new Set()),
+    resolveStylePPr: (styleId) => resolvePPr(styleId, /* @__PURE__ */ new Set()),
+    resolveTableBorders: (styleId) => resolveTblBorders(styleId, /* @__PURE__ */ new Set())
+  };
+}
+
+// packages/docx/src/lib/numbering.ts
+function buildNumbering(numberingRoot) {
+  const numberingEl = child(numberingRoot, "w:numbering");
+  const abstract = /* @__PURE__ */ new Map();
+  for (const abstractNum of children(numberingEl, "w:abstractNum")) {
+    const id = attrOf(abstractNum, "w:abstractNumId");
+    if (id === void 0) continue;
+    const levels = /* @__PURE__ */ new Map();
+    for (const lvl of children(abstractNum, "w:lvl")) {
+      const ilvl = Number(attrOf(lvl, "w:ilvl") ?? "0");
+      levels.set(Number.isNaN(ilvl) ? 0 : ilvl, {
+        numFmt: attrOf(child(lvl, "w:numFmt"), "w:val") ?? "decimal",
+        lvlText: attrOf(child(lvl, "w:lvlText"), "w:val") ?? "",
+        start: Number(attrOf(child(lvl, "w:start"), "w:val") ?? "1") || 1,
+        pPr: child(lvl, "w:pPr")
+      });
+    }
+    abstract.set(id, levels);
+  }
+  const numToAbstract = /* @__PURE__ */ new Map();
+  for (const num of children(numberingEl, "w:num")) {
+    const numId = attrOf(num, "w:numId");
+    const absId = attrOf(child(num, "w:abstractNumId"), "w:val");
+    if (numId !== void 0 && absId !== void 0) numToAbstract.set(numId, absId);
+  }
+  let defs = null;
+  for (const [numId, absId] of numToAbstract) {
+    const levels = abstract.get(absId);
+    if (!levels) continue;
+    const plain = {};
+    for (const [ilvl, def] of levels) {
+      plain[ilvl] = { numFmt: def.numFmt, lvlText: def.lvlText, start: def.start };
+    }
+    (defs ??= {})[numId] = { key: absId, levels: plain };
+  }
+  function levelPPr(numId, level) {
+    const absId = numToAbstract.get(numId);
+    return absId === void 0 ? void 0 : abstract.get(absId)?.get(level)?.pPr;
+  }
+  return { defs, levelPPr };
+}
+
+// packages/docx/src/lib/rels.ts
+function buildRels(root) {
+  const map = /* @__PURE__ */ new Map();
+  for (const rel of children(child(root, "Relationships"), "Relationship")) {
+    const id = attrOf(rel, "Id");
+    const target = attrOf(rel, "Target");
+    if (id && target) {
+      map.set(id, { target, external: attrOf(rel, "TargetMode") === "External" });
+    }
+  }
+  return map;
+}
+
+// packages/docx/src/lib/theme.ts
+var ALIASES = {
+  dk1: ["dark1", "text1"],
+  lt1: ["light1", "background1"],
+  dk2: ["dark2", "text2"],
+  lt2: ["light2", "background2"],
+  accent1: ["accent1"],
+  accent2: ["accent2"],
+  accent3: ["accent3"],
+  accent4: ["accent4"],
+  accent5: ["accent5"],
+  accent6: ["accent6"],
+  hlink: ["hyperlink"],
+  folHlink: ["followedHyperlink"]
+};
+function schemeColor(el) {
+  const srgb = child(el, "a:srgbClr");
+  const srgbVal = attrOf(srgb, "val");
+  if (srgbVal) return `#${srgbVal.toUpperCase()}`;
+  const sys = child(el, "a:sysClr");
+  const sysVal = attrOf(sys, "lastClr") ?? attrOf(sys, "val");
+  if (sysVal) return `#${sysVal.toUpperCase()}`;
+  return void 0;
+}
+var clamp = (n) => Math.max(0, Math.min(255, Math.round(n)));
+var hex2 = (n) => clamp(n).toString(16).padStart(2, "0").toUpperCase();
+function applyTintShade(hex, tint, shade) {
+  let r = parseInt(hex.slice(1, 3), 16);
+  let g = parseInt(hex.slice(3, 5), 16);
+  let b = parseInt(hex.slice(5, 7), 16);
+  if (shade !== void 0) {
+    const f = parseInt(shade, 16) / 255;
+    r *= f;
+    g *= f;
+    b *= f;
+  }
+  if (tint !== void 0) {
+    const f = parseInt(tint, 16) / 255;
+    r = r * f + 255 * (1 - f);
+    g = g * f + 255 * (1 - f);
+    b = b * f + 255 * (1 - f);
+  }
+  return `#${hex2(r)}${hex2(g)}${hex2(b)}`;
+}
+function buildThemeResolver(themeRoot) {
+  const map = /* @__PURE__ */ new Map();
+  const scheme = findDescendant(themeRoot, "a:clrScheme");
+  for (const el of scheme?.children ?? []) {
+    const key = el.name.startsWith("a:") ? el.name.slice(2) : el.name;
+    const color = schemeColor(el);
+    if (!color) continue;
+    map.set(key, color);
+    for (const alias of ALIASES[key] ?? []) map.set(alias, color);
+  }
+  return (themeColor, tint, shade) => {
+    const base = map.get(themeColor);
+    if (!base) return void 0;
+    return tint === void 0 && shade === void 0 ? base : applyTintShade(base, tint, shade);
+  };
+}
+
+// packages/docx/src/lib/docx.ts
+var twipsToPx = (twips) => Math.round(twips / 15);
+function emuToPx(emu) {
+  const n = Number(emu ?? "0");
+  return Number.isNaN(n) || n === 0 ? null : Math.round(n / 9525);
+}
+function mimeOf(path) {
+  switch (path.slice(path.lastIndexOf(".") + 1).toLowerCase()) {
+    case "png":
+      return "image/png";
+    case "jpg":
+    case "jpeg":
+      return "image/jpeg";
+    case "gif":
+      return "image/gif";
+    case "bmp":
+      return "image/bmp";
+    case "svg":
+      return "image/svg+xml";
+    case "webp":
+      return "image/webp";
+    case "tif":
+    case "tiff":
+      return "image/tiff";
+    default:
+      return "application/octet-stream";
+  }
+}
+function propsToMarks(p, ctx) {
+  const marks = [];
+  if (p.bold) marks.push(ctx.schema.marks["strong"].create());
+  if (p.italic) marks.push(ctx.schema.marks["em"].create());
+  if (p.underline) marks.push(ctx.schema.marks["underline"].create());
+  if (p.strike) marks.push(ctx.schema.marks["strike"].create());
+  if (p.color) marks.push(ctx.schema.marks["textColor"].create({ color: p.color }));
+  if (p.sizePt !== void 0) marks.push(ctx.schema.marks["fontSize"].create({ size: p.sizePt }));
+  if (p.fontFamily) marks.push(ctx.schema.marks["fontFamily"].create({ family: p.fontFamily }));
+  if (p.highlight) marks.push(ctx.schema.marks["highlight"].create({ color: p.highlight }));
+  if (p.vertAlign) marks.push(ctx.schema.marks["vertAlign"].create({ value: p.vertAlign }));
+  return marks;
+}
+var SYMBOL_MAP = {
+  F0B7: "\u2022",
+  F06C: "\u25CF",
+  F0A7: "\u25AA",
+  F0A8: "\u25AB",
+  F0FC: "\u2714",
+  F0FB: "\u2717",
+  F0E0: "\u2192"
+};
+function symbolChar(code) {
+  if (!code) return "";
+  const upper = code.toUpperCase();
+  if (SYMBOL_MAP[upper]) return SYMBOL_MAP[upper];
+  const n = parseInt(code, 16);
+  return Number.isNaN(n) ? "" : String.fromCodePoint(n >= 61440 ? n - 61440 + 32 : n);
+}
+function hasPageBreak(run) {
+  return run.children.some((n) => n.name === "w:br" && attrOf(n, "w:type") === "page");
+}
+function effectiveChildren(nodes) {
+  const out = [];
+  for (const node of nodes) {
+    if (node.name === "w:del" || node.name === "w:moveFrom") continue;
+    if (node.name === "w:ins" || node.name === "w:moveTo") {
+      out.push(...effectiveChildren(node.children));
+    } else if (node.name === "w:sdt") {
+      out.push(...effectiveChildren(unwrapSdt([node])));
+    } else {
+      out.push(node);
+    }
+  }
+  return out;
+}
+function unwrapSdt(nodes) {
+  const out = [];
+  for (const node of nodes) {
+    if (node.name === "w:sdt") {
+      const content = child(node, "w:sdtContent");
+      if (content) out.push(...unwrapSdt(content.children));
+    } else {
+      out.push(node);
+    }
+  }
+  return out;
+}
+function runInlineNodes(run, marks, ctx) {
+  const group = parseGroup(run, ctx);
+  if (group) return group;
+  const image = parseImage(run, ctx) ?? parseShape(run, ctx) ?? parseVmlImage(run, ctx);
+  if (image) return [image];
+  const out = [];
+  let buf = "";
+  const flush = () => {
+    if (buf.length > 0) out.push(ctx.schema.text(buf, marks));
+    buf = "";
+  };
+  for (const node of run.children) {
+    if (node.name === "w:t") buf += node.text;
+    else if (node.name === "w:tab") buf += "	";
+    else if (node.name === "w:sym") buf += symbolChar(attrOf(node, "w:char"));
+    else if (node.name === "w:footnoteReference" || node.name === "w:endnoteReference") {
+      const kind = node.name === "w:footnoteReference" ? "footnote" : "endnote";
+      const id = attrOf(node, "w:id");
+      if (id && ctx.notes.bodies[kind].has(id)) {
+        flush();
+        const num = ctx.notes.ref(kind, id);
+        const refMarks = [...marks, ctx.schema.marks["vertAlign"].create({ value: "super" })];
+        if (kind === "footnote") refMarks.push(ctx.schema.marks["footnote"].create({ num }));
+        out.push(ctx.schema.text(String(num), refMarks));
+      }
+    } else if (node.name === "w:br" && attrOf(node, "w:type") !== "page") {
+      flush();
+      out.push(ctx.schema.nodes["hard_break"].create());
+    }
+  }
+  flush();
+  return out;
+}
+function emuToPxZero(emu) {
+  if (emu === void 0) return void 0;
+  const n = Number(emu);
+  return Number.isNaN(n) ? void 0 : Math.round(n / 9525);
+}
+function parseAnchorFloat(drawing) {
+  const anchor = child(drawing, "wp:anchor");
+  if (!anchor) return null;
+  const wrap = child(anchor, "wp:wrapTopAndBottom") ? "topAndBottom" : child(anchor, "wp:wrapSquare") || child(anchor, "wp:wrapTight") || child(anchor, "wp:wrapThrough") ? "square" : "none";
+  const float = { wrap };
+  const posH = child(anchor, "wp:positionH");
+  if (posH) {
+    const align = child(posH, "wp:align")?.text.trim();
+    if (align === "left" || align === "right" || align === "center") float["hAlign"] = align;
+    const off = emuToPxZero(child(posH, "wp:posOffset")?.text);
+    if (off !== void 0 && float["hAlign"] === void 0) float["hOffset"] = off;
+    const rel = attrOf(posH, "relativeFrom");
+    float["hRel"] = rel === "page" ? "page" : "margin";
+  }
+  const posV = child(anchor, "wp:positionV");
+  if (posV) {
+    const off = emuToPxZero(child(posV, "wp:posOffset")?.text);
+    if (off !== void 0) float["vOffset"] = off;
+    const rel = attrOf(posV, "relativeFrom");
+    float["vRel"] = rel === "page" ? "page" : rel === "margin" ? "margin" : "paragraph";
+  }
+  for (const side of ["distL", "distR", "distT", "distB"]) {
+    const v = emuToPxZero(attrOf(anchor, side));
+    if (v !== void 0) float[side] = v;
+  }
+  return float;
+}
+function runDrawing(run) {
+  const direct = child(run, "w:drawing");
+  if (direct) return direct;
+  const alt = child(run, "mc:AlternateContent");
+  if (!alt) return void 0;
+  for (const branch of ["mc:Choice", "mc:Fallback"]) {
+    for (const b of children(alt, branch)) {
+      const d = child(b, "w:drawing");
+      if (d) return d;
+    }
+  }
+  return void 0;
+}
+function parseGroup(run, ctx) {
+  const drawing = runDrawing(run);
+  if (!drawing) return null;
+  const wgp = findDescendant(drawing, "wpg:wgp");
+  if (!wgp) return null;
+  const baseFloat = parseAnchorFloat(drawing);
+  if (!baseFloat) return null;
+  const num = (n, a) => Number(attrOf(n, a) ?? "0");
+  const xfrm = child(child(wgp, "wpg:grpSpPr"), "a:xfrm");
+  const ext = child(xfrm, "a:ext");
+  const chOff = child(xfrm, "a:chOff");
+  const chExt = child(xfrm, "a:chExt");
+  const chW = num(chExt, "cx") || num(ext, "cx") || 1;
+  const chH = num(chExt, "cy") || num(ext, "cy") || 1;
+  const sx = (num(ext, "cx") || chW) / chW;
+  const sy = (num(ext, "cy") || chH) / chH;
+  const out = [];
+  for (const pic of children(wgp, "pic:pic")) {
+    const blip = findDescendant(pic, "a:blip");
+    const embed = attrOf(blip, "r:embed") ?? attrOf(blip, "r:link");
+    const rel = embed ? ctx.rels.get(embed) : void 0;
+    if (!rel) continue;
+    const target = rel.target.replace(/^\/+/, "");
+    const src = ctx.media.get(`word/${target}`) ?? ctx.media.get(target);
+    if (!src) continue;
+    const picXfrm = child(child(pic, "pic:spPr"), "a:xfrm");
+    const off = child(picXfrm, "a:off");
+    const cext = child(picXfrm, "a:ext");
+    const emuPx = (emu) => Math.round(emu / 9525);
+    out.push(
+      ctx.schema.nodes["image"].create({
+        src,
+        width: emuPx(num(cext, "cx") * sx),
+        height: emuPx(num(cext, "cy") * sy),
+        alt: attrOf(findDescendant(pic, "pic:cNvPr"), "descr") ?? "",
+        float: {
+          ...baseFloat,
+          hOffset: (baseFloat["hOffset"] ?? 0) + emuPx((num(off, "x") - num(chOff, "x")) * sx),
+          vOffset: (baseFloat["vOffset"] ?? 0) + emuPx((num(off, "y") - num(chOff, "y")) * sy)
+        }
+      })
+    );
+  }
+  return out.length > 0 ? out : null;
+}
+function xfrmRotation(root) {
+  const rot = Number(attrOf(findDescendant(root, "a:xfrm"), "rot"));
+  return rot ? Math.round(rot / 6e4 * 100) / 100 : 0;
+}
+function parseImage(run, ctx) {
+  const drawing = runDrawing(run);
+  if (!drawing) return null;
+  const blip = findDescendant(drawing, "a:blip");
+  const embed = attrOf(blip, "r:embed") ?? attrOf(blip, "r:link");
+  const rel = embed ? ctx.rels.get(embed) : void 0;
+  if (!rel) return null;
+  const target = rel.target.replace(/^\/+/, "");
+  const src = ctx.media.get(`word/${target}`) ?? ctx.media.get(target);
+  if (!src) return null;
+  const extent = findDescendant(drawing, "wp:extent");
+  const docPr = findDescendant(drawing, "wp:docPr");
+  const float = parseAnchorFloat(drawing);
+  return ctx.schema.nodes["image"].create({
+    src,
+    width: emuToPx(attrOf(extent, "cx")),
+    height: emuToPx(attrOf(extent, "cy")),
+    alt: attrOf(docPr, "descr") ?? attrOf(docPr, "title") ?? "",
+    float,
+    rotation: xfrmRotation(drawing)
+  });
+}
+function parseVmlImage(run, ctx) {
+  const holder = child(run, "w:object") ?? child(run, "w:pict");
+  if (!holder) return null;
+  const imagedata = findDescendant(holder, "v:imagedata");
+  const rid = attrOf(imagedata, "r:id");
+  const rel = rid ? ctx.rels.get(rid) : void 0;
+  if (!rel) return null;
+  const target = rel.target.replace(/^\/+/, "");
+  const src = ctx.media.get(`word/${target}`) ?? ctx.media.get(target);
+  if (!src) return null;
+  const style = attrOf(findDescendant(holder, "v:shape"), "style") ?? "";
+  const ptToPx = (m) => m ? Math.round(parseFloat(m[1]) * 96 / 72) : null;
+  const width = ptToPx(/(?:^|;)width:([\d.]+)pt/.exec(style)) ?? (Number(attrOf(holder, "w:dxaOrig")) ? twipsToPx(Number(attrOf(holder, "w:dxaOrig"))) : null);
+  const height = ptToPx(/(?:^|;)height:([\d.]+)pt/.exec(style)) ?? (Number(attrOf(holder, "w:dyaOrig")) ? twipsToPx(Number(attrOf(holder, "w:dyaOrig"))) : null);
+  return ctx.schema.nodes["image"].create({
+    src,
+    width,
+    height,
+    alt: attrOf(imagedata, "o:title") ?? "",
+    float: null
+  });
+}
+function solidFillColor(node, ctx) {
+  const fill = child(node, "a:solidFill");
+  if (!fill) return void 0;
+  const srgb = attrOf(child(fill, "a:srgbClr"), "val");
+  if (srgb) return `#${srgb}`;
+  const scheme = attrOf(child(fill, "a:schemeClr"), "val");
+  return scheme ? ctx.resolveTheme(scheme) : void 0;
+}
+function parseShape(run, ctx) {
+  const drawing = runDrawing(run);
+  if (!drawing) return null;
+  const wsp = findDescendant(drawing, "wps:wsp");
+  const spPr = child(wsp, "wps:spPr");
+  const prst = attrOf(child(spPr, "a:prstGeom"), "prst");
+  const textbox = parseTextbox(wsp, ctx);
+  const KIND = {
+    rect: "rect",
+    line: "line",
+    straightConnector1: "line",
+    ellipse: "ellipse",
+    roundRect: "roundRect",
+    rightArrow: "rightArrow",
+    horizontalScroll: "horizontalScroll"
+  };
+  const kind = prst && KIND[prst] || (textbox ? "rect" : null);
+  if (!kind) return null;
+  const shape = { kind };
+  const ln = child(spPr, "a:ln");
+  if (!child(ln, "a:noFill")) {
+    const w = attrOf(ln, "w");
+    shape["strokeWidth"] = w ? Math.max(1, Math.round(Number(w) / 9525)) : 1;
+    const lnRef = findDescendant(child(wsp, "wps:style"), "a:lnRef");
+    const refScheme = attrOf(child(lnRef, "a:schemeClr"), "val");
+    shape["stroke"] = solidFillColor(ln, ctx) ?? (refScheme ? ctx.resolveTheme(refScheme) : void 0) ?? "#000000";
+  }
+  const fill = solidFillColor(spPr, ctx);
+  if (fill) shape["fill"] = fill;
+  if (attrOf(child(spPr, "a:xfrm"), "flipV") === "1") shape["flipV"] = true;
+  const extent = findDescendant(drawing, "wp:extent");
+  const docPr = findDescendant(drawing, "wp:docPr");
+  return ctx.schema.nodes["image"].create({
+    src: "",
+    width: emuToPxZero(attrOf(extent, "cx")) ?? 0,
+    height: emuToPxZero(attrOf(extent, "cy")) ?? 0,
+    alt: attrOf(docPr, "name") ?? kind,
+    float: parseAnchorFloat(drawing),
+    shape,
+    textbox,
+    rotation: xfrmRotation(spPr)
+  });
+}
+function parseTextbox(wsp, ctx) {
+  const content = child(child(wsp, "wps:txbx"), "w:txbxContent");
+  if (!content) return null;
+  const paragraphs = children(content, "w:p").map((p) => parseParagraph(p, ctx).toJSON());
+  if (paragraphs.length === 0) return null;
+  const bodyPr = child(wsp, "wps:bodyPr");
+  const ins = (name) => emuToPxZero(attrOf(bodyPr, name));
+  const l = ins("lIns"), t = ins("tIns"), r = ins("rIns"), b = ins("bIns");
+  const inset = l !== void 0 || t !== void 0 || r !== void 0 || b !== void 0 ? { l: l ?? 10, t: t ?? 5, r: r ?? 10, b: b ?? 5 } : void 0;
+  return inset ? { paragraphs, inset } : { paragraphs };
+}
+function runMarks(run, paraBase, ctx, href) {
+  const rPr = child(run, "w:rPr");
+  const rStyleId = attrOf(child(rPr, "w:rStyle"), "w:val");
+  const effective = [
+    paraBase,
+    ctx.styles.resolveStyle(rStyleId),
+    parseRunProps(rPr, ctx.resolveTheme)
+  ].reduce(mergeRunProps, {});
+  const marks = propsToMarks(effective, ctx);
+  if (href) marks.push(ctx.schema.marks["link"].create({ href }));
+  if (ctx.comments.active.size > 0 && ctx.schema.marks["comment"]) {
+    const ids = [...ctx.comments.active].sort((a, b) => a - b);
+    marks.push(ctx.schema.marks["comment"].create({ ids }));
+  }
+  return marks;
+}
+function runToInline(run, paraBase, ctx, href) {
+  const marks = runMarks(run, paraBase, ctx, href);
+  const nodes = runInlineNodes(run, marks, ctx);
+  return href ? nodes.map((n) => n.type.name === "image" ? n.mark(marks) : n) : nodes;
+}
+function fieldKind(instr) {
+  if (/\bNUMPAGES\b/.test(instr)) return "pages";
+  if (/\bPAGE\b/.test(instr)) return "page";
+  return null;
+}
+function pageFieldNode(kind, formatRun, paraBase, ctx) {
+  return ctx.schema.nodes["page_field"].create({ kind }).mark(runMarks(formatRun, paraBase, ctx, null));
+}
+function headingLevel(pStyleId, pPrChain) {
+  if (pStyleId) {
+    const m = /^heading\s*([1-9])$/i.exec(pStyleId);
+    if (m) return Math.min(6, Number(m[1]));
+  }
+  const ol = lastWith(pPrChain, "w:outlineLvl");
+  if (ol) {
+    const v = Number(attrOf(ol, "w:val"));
+    if (!Number.isNaN(v) && v >= 0 && v <= 8) return Math.min(6, v + 1);
+  }
+  return void 0;
+}
+var SUB_DIGITS = "\u2080\u2081\u2082\u2083\u2084\u2085\u2086\u2087\u2088\u2089";
+var SUP_DIGITS = "\u2070\xB9\xB2\xB3\u2074\u2075\u2076\u2077\u2078\u2079";
+function scriptDigits(text, alphabet) {
+  if (!/^[0-9]+$/.test(text)) return null;
+  return [...text].map((d) => alphabet[Number(d)]).join("");
+}
+function flattenOmml(node) {
+  const flat = (n) => n ? flattenOmml(n) : "";
+  switch (node.name) {
+    case "m:t":
+      return node.text;
+    case "m:f": {
+      const side = (s) => /[+\-±×÷/ ]/.test(s) ? `(${s})` : s;
+      return `${side(flat(child(node, "m:num")))}/${side(flat(child(node, "m:den")))}`;
+    }
+    case "m:sSub": {
+      const sub = flat(child(node, "m:sub"));
+      return flat(child(node, "m:e")) + (scriptDigits(sub, SUB_DIGITS) ?? `_(${sub})`);
+    }
+    case "m:sSup": {
+      const sup = flat(child(node, "m:sup"));
+      return flat(child(node, "m:e")) + (scriptDigits(sup, SUP_DIGITS) ?? `^(${sup})`);
+    }
+    case "m:sSubSup": {
+      const sub = flat(child(node, "m:sub"));
+      const sup = flat(child(node, "m:sup"));
+      return flat(child(node, "m:e")) + (scriptDigits(sub, SUB_DIGITS) ?? `_(${sub})`) + (scriptDigits(sup, SUP_DIGITS) ?? `^(${sup})`);
+    }
+    case "m:rad": {
+      const deg = flat(child(node, "m:deg"));
+      return `${deg}\u221A(${flat(child(node, "m:e"))})`;
+    }
+    case "m:d": {
+      const pr = child(node, "m:dPr");
+      const chr = (name, dflt) => attrOf(child(pr, name), "m:val") ?? dflt;
+      const args = children(node, "m:e").map(flat);
+      return chr("m:begChr", "(") + args.join(chr("m:sepChr", ",")) + chr("m:endChr", ")");
+    }
+    default:
+      if (node.name.startsWith("m:") && node.name.endsWith("Pr")) return "";
+      return node.children.map(flat).join("");
+  }
+}
+function parseParagraph(p, ctx) {
+  const pPr = child(p, "w:pPr");
+  const pStyleId = attrOf(child(pPr, "w:pStyle"), "w:val");
+  const paraBase = mergeRunProps(ctx.styles.docDefaults, ctx.styles.resolveStyle(pStyleId));
+  const pPrChain = [
+    ctx.styles.docDefaultsPPr,
+    ...ctx.styles.resolveStylePPr(pStyleId),
+    pPr
+  ];
+  const list = parseList(lastWith(pPrChain, "w:numPr"));
+  if (list) {
+    const lvlPPr = ctx.numbering.levelPPr(list.numId, list.level);
+    if (lvlPPr) pPrChain.splice(pPrChain.length - 1, 0, lvlPPr);
+  }
+  const align = resolveAlign(pPrChain);
+  const indent = resolveIndent(pPrChain);
+  const spacing = resolveSpacing(pPrChain);
+  const tabs = resolveTabs(pPrChain);
+  const heading = headingLevel(pStyleId, pPrChain);
+  const inline = [];
+  let field = null;
+  let pageBreak = lastWith(pPrChain, "w:pageBreakBefore") !== void 0;
+  for (const node of effectiveChildren(p.children)) {
+    if (node.name === "w:r") {
+      if (hasPageBreak(node)) pageBreak = true;
+      const fldType = attrOf(child(node, "w:fldChar"), "w:fldCharType");
+      if (fldType === "begin") {
+        field = { instr: "", resultRuns: [], phase: "instr" };
+        continue;
+      }
+      if (field) {
+        if (fldType === "separate") {
+          field.phase = "result";
+        } else if (fldType === "end") {
+          const kind = fieldKind(field.instr);
+          if (kind) {
+            inline.push(pageFieldNode(kind, field.resultRuns[0], paraBase, ctx));
+          } else {
+            for (const r of field.resultRuns) inline.push(...runToInline(r, paraBase, ctx, null));
+          }
+          field = null;
+        } else if (field.phase === "instr") {
+          field.instr += children(node, "w:instrText").map((t) => t.text).join("");
+        } else {
+          field.resultRuns.push(node);
+        }
+        continue;
+      }
+      inline.push(...runToInline(node, paraBase, ctx, null));
+    } else if (node.name === "w:fldSimple") {
+      const kind = fieldKind(attrOf(node, "w:instr") ?? "");
+      const resultRuns = children(node, "w:r");
+      if (kind) {
+        inline.push(pageFieldNode(kind, resultRuns[0], paraBase, ctx));
+      } else {
+        for (const r of resultRuns) inline.push(...runToInline(r, paraBase, ctx, null));
+      }
+    } else if (node.name === "w:hyperlink") {
+      const rel = attrOf(node, "r:id") ? ctx.rels.get(attrOf(node, "r:id")) : void 0;
+      const anchor = attrOf(node, "w:anchor");
+      const href = rel?.target ?? (anchor ? `#${anchor}` : null);
+      for (const run of children(node, "w:r")) {
+        inline.push(...runToInline(run, paraBase, ctx, href));
+      }
+    } else if (node.name === "m:oMath" || node.name === "m:oMathPara") {
+      const text = flattenOmml(node);
+      if (text.length > 0) {
+        const first = findDescendant(node, "m:r");
+        inline.push(ctx.schema.text(text, runMarks(first, paraBase, ctx, null)));
+      }
+    } else if (node.name === "w:commentRangeStart") {
+      const id = Number(attrOf(node, "w:id"));
+      if (!Number.isNaN(id) && ctx.comments.defs.has(id)) {
+        ctx.comments.active.add(id);
+        if (!ctx.comments.used.includes(id)) ctx.comments.used.push(id);
+      }
+    } else if (node.name === "w:commentRangeEnd") {
+      const id = Number(attrOf(node, "w:id"));
+      if (!Number.isNaN(id)) ctx.comments.active.delete(id);
+    }
+  }
+  const attrs = {};
+  if (list) attrs.list = list;
+  if (align) attrs.align = align;
+  if (heading) attrs.heading = heading;
+  if (indent) attrs.indent = indent;
+  if (spacing) attrs.spacing = spacing;
+  if (tabs) attrs.tabs = tabs;
+  if (pageBreak) attrs.pageBreakBefore = true;
+  return ctx.schema.nodes["paragraph"].create(attrs, inline);
+}
+function resolveTabs(chain) {
+  const layer = lastWith(chain, "w:tabs");
+  if (!layer) return null;
+  const stops = [];
+  for (const tab of children(child(layer, "w:tabs"), "w:tab")) {
+    const val = attrOf(tab, "w:val") ?? "left";
+    if (val === "clear" || val === "bar") continue;
+    const pos = attrOf(tab, "w:pos");
+    if (pos === void 0) continue;
+    const stop = {
+      pos: twipsToPx(Number(pos)),
+      val: val === "right" || val === "center" || val === "decimal" ? val : "left"
+    };
+    const leader = attrOf(tab, "w:leader");
+    if (leader && leader !== "none") {
+      stop.leader = leader === "hyphen" ? "hyphen" : leader === "underscore" ? "underscore" : leader === "middleDot" ? "middleDot" : "dot";
+    }
+    stops.push(stop);
+  }
+  return stops.length > 0 ? stops.sort((a, b) => a.pos - b.pos) : null;
+}
+function lastWith(chain, childName) {
+  for (let i = chain.length - 1; i >= 0; i--) {
+    if (child(chain[i], childName)) return chain[i];
+  }
+  return void 0;
+}
+function resolveAlign(chain) {
+  for (let i = chain.length - 1; i >= 0; i--) {
+    const align = parseAlign(chain[i]);
+    if (align) return align;
+  }
+  return null;
+}
+function resolveIndent(chain) {
+  let left;
+  let right;
+  let firstLine;
+  let hanging;
+  for (const pPr of chain) {
+    const ind = child(pPr, "w:ind");
+    if (!ind) continue;
+    const px = (attr) => {
+      const v = attrOf(ind, attr);
+      return v === void 0 ? void 0 : twipsToPx(Number(v));
+    };
+    left = px("w:left") ?? px("w:start") ?? left;
+    right = px("w:right") ?? px("w:end") ?? right;
+    const fl = px("w:firstLine");
+    const hg = px("w:hanging");
+    if (fl !== void 0 || hg !== void 0) {
+      firstLine = fl;
+      hanging = hg;
+    }
+  }
+  const out = {};
+  if (left !== void 0) out.left = left;
+  if (right !== void 0) out.right = right;
+  if (hanging !== void 0) out.hanging = hanging;
+  else if (firstLine !== void 0) out.firstLine = firstLine;
+  return Object.keys(out).length > 0 ? out : null;
+}
+function resolveSpacing(chain) {
+  const out = {};
+  for (const pPr of chain) {
+    const sp = child(pPr, "w:spacing");
+    if (!sp) continue;
+    const before = attrOf(sp, "w:before");
+    const after = attrOf(sp, "w:after");
+    const line = attrOf(sp, "w:line");
+    const rule = attrOf(sp, "w:lineRule");
+    if (before !== void 0) out.before = twipsToPx(Number(before));
+    if (after !== void 0) out.after = twipsToPx(Number(after));
+    if (line !== void 0) {
+      const lineRule = rule === "exact" || rule === "atLeast" ? rule : "auto";
+      out.lineRule = lineRule;
+      out.line = lineRule === "auto" ? Number(line) / 240 : twipsToPx(Number(line));
+    }
+  }
+  return Object.keys(out).length > 0 ? out : null;
+}
+function parseAlign(pPr) {
+  switch (attrOf(child(pPr, "w:jc"), "w:val")) {
+    case "center":
+      return "center";
+    case "right":
+    case "end":
+      return "right";
+    case "both":
+    case "distribute":
+      return "justify";
+    case "left":
+    case "start":
+      return "left";
+    default:
+      return null;
+  }
+}
+function parseList(pPr) {
+  const numPr = child(pPr, "w:numPr");
+  const numId = attrOf(child(numPr, "w:numId"), "w:val");
+  if (numId === void 0 || numId === "0") return null;
+  const ilvl = Number(attrOf(child(numPr, "w:ilvl"), "w:val") ?? "0");
+  return { numId, level: Number.isNaN(ilvl) ? 0 : ilvl };
+}
+function emptyCell(ctx) {
+  return ctx.schema.nodes["table_cell"].create(null, [ctx.schema.nodes["paragraph"].create()]);
+}
+function parseCellMargins(tbl) {
+  const mar = child(child(tbl, "w:tblPr"), "w:tblCellMar");
+  if (!mar) return null;
+  const side = (name) => {
+    const el = child(mar, name);
+    if (!el) return void 0;
+    if (attrOf(el, "w:type") === "nil") return 0;
+    const w = attrOf(el, "w:w");
+    return w === void 0 ? void 0 : twipsToPx(Number(w));
+  };
+  const out = {};
+  const left = side("w:left") ?? side("w:start");
+  const right = side("w:right") ?? side("w:end");
+  const top = side("w:top");
+  const bottom = side("w:bottom");
+  if (left !== void 0) out.left = left;
+  if (right !== void 0) out.right = right;
+  if (top !== void 0) out.top = top;
+  if (bottom !== void 0) out.bottom = bottom;
+  return Object.keys(out).length > 0 ? out : null;
+}
+var BORDER_STYLE_IN = {
+  single: "solid",
+  thick: "solid",
+  dashed: "dashed",
+  dashSmallGap: "dashed",
+  dotted: "dotted",
+  dotDash: "dashed",
+  dotDotDash: "dashed",
+  double: "double"
+};
+function parseBorderSide(el) {
+  const val = attrOf(el, "w:val");
+  if (val === "none" || val === "nil") return false;
+  const sz = Number(attrOf(el, "w:sz") ?? "4");
+  const width = Math.max(0.75, sz / 8 * (96 / 72));
+  const style = BORDER_STYLE_IN[val ?? "single"] ?? "solid";
+  const colorAttr = attrOf(el, "w:color");
+  const color = colorAttr && colorAttr !== "auto" ? normalizeHex(colorAttr) ?? "#b0b0b0" : "#b0b0b0";
+  return { width, style, color };
+}
+function parseBordersEl(bordersEl, sides) {
+  if (!bordersEl) return null;
+  const out = {};
+  for (const side of sides) {
+    const el = child(bordersEl, `w:${side}`);
+    if (!el) continue;
+    out[side] = parseBorderSide(el);
+  }
+  return Object.keys(out).length > 0 ? out : null;
+}
+var TABLE_SIDES = ["top", "bottom", "left", "right", "insideH", "insideV"];
+var CELL_SIDES = ["top", "bottom", "left", "right"];
+function parseTableBorders(tbl, ctx) {
+  const tblPr = child(tbl, "w:tblPr");
+  const styleId = attrOf(child(tblPr, "w:tblStyle"), "w:val");
+  const bordersEl = child(tblPr, "w:tblBorders") ?? ctx.styles.resolveTableBorders(styleId);
+  const out = parseBordersEl(bordersEl, TABLE_SIDES);
+  return out && Object.values(out).some(Boolean) ? out : null;
+}
+function parseTable(tbl, ctx) {
+  const grid = children(child(tbl, "w:tblGrid"), "w:gridCol").map(
+    (c) => Number(attrOf(c, "w:w") ?? "0")
+  );
+  const logicalRows = children(tbl, "w:tr").map((tr) => {
+    const cells = [];
+    let col = 0;
+    for (const tc of children(tr, "w:tc")) {
+      const tcPr = child(tc, "w:tcPr");
+      const colspan = Number(attrOf(child(tcPr, "w:gridSpan"), "w:val") ?? "1") || 1;
+      const vMergeEl = child(tcPr, "w:vMerge");
+      const vMerge = !vMergeEl ? null : attrOf(vMergeEl, "w:val") === "restart" ? "restart" : "continue";
+      const widths = grid.length ? grid.slice(col, col + colspan).map(twipsToPx) : [];
+      const background = normalizeHex(attrOf(child(tcPr, "w:shd"), "w:fill")) ?? null;
+      const vAlignVal = attrOf(child(tcPr, "w:vAlign"), "w:val");
+      const vAlign = vAlignVal === "center" || vAlignVal === "bottom" ? vAlignVal : null;
+      const borders2 = parseBordersEl(child(tcPr, "w:tcBorders"), CELL_SIDES);
+      const content = parseBlocks(tc, ctx);
+      if (content.length === 0) content.push(ctx.schema.nodes["paragraph"].create());
+      cells.push({ startCol: col, colspan, vMerge, colwidth: widths.length ? widths : null, background, vAlign, borders: borders2, content });
+      col += colspan;
+    }
+    return cells;
+  });
+  const rowProps = children(tbl, "w:tr").map((tr) => {
+    const trPr = child(tr, "w:trPr");
+    const hdr = child(trPr, "w:tblHeader");
+    const header = hdr ? attrOf(hdr, "w:val") !== "false" && attrOf(hdr, "w:val") !== "0" : false;
+    const trH = child(trPr, "w:trHeight");
+    const hv = attrOf(trH, "w:val");
+    const height = hv !== void 0 ? { value: twipsToPx(Number(hv)), exact: attrOf(trH, "w:hRule") === "exact" } : null;
+    const cs = child(trPr, "w:cantSplit");
+    const cantSplit = cs ? attrOf(cs, "w:val") !== "false" && attrOf(cs, "w:val") !== "0" : false;
+    return { header, height, cantSplit };
+  });
+  const colIndex = logicalRows.map((cells) => new Map(cells.map((c) => [c.startCol, c])));
+  const rows = logicalRows.map((cells, r) => {
+    const emitted = [];
+    for (const cell of cells) {
+      if (cell.vMerge === "continue") continue;
+      let rowspan = 1;
+      for (let r2 = r + 1; r2 < logicalRows.length; r2++) {
+        const below = colIndex[r2].get(cell.startCol);
+        if (below && below.vMerge === "continue") rowspan++;
+        else break;
+      }
+      emitted.push(
+        ctx.schema.nodes["table_cell"].create(
+          {
+            colspan: cell.colspan,
+            rowspan,
+            colwidth: cell.colwidth,
+            background: cell.background,
+            vAlign: cell.vAlign,
+            borders: cell.borders
+          },
+          cell.content
+        )
+      );
+    }
+    const rp = rowProps[r];
+    const rowAttrs = {};
+    if (rp.header) rowAttrs["header"] = true;
+    if (rp.height) rowAttrs["height"] = rp.height;
+    if (rp.cantSplit) rowAttrs["cantSplit"] = true;
+    return ctx.schema.nodes["table_row"].create(
+      Object.keys(rowAttrs).length > 0 ? rowAttrs : null,
+      emitted.length > 0 ? emitted : [emptyCell(ctx)]
+    );
+  });
+  const cellPadding = parseCellMargins(tbl);
+  const borders = parseTableBorders(tbl, ctx);
+  const jc = attrOf(child(child(tbl, "w:tblPr"), "w:jc"), "w:val");
+  const attrs = {};
+  if (cellPadding) attrs["cellPadding"] = cellPadding;
+  if (borders) attrs["borders"] = borders;
+  if (jc === "center" || jc === "right" || jc === "end") attrs["align"] = jc === "end" ? "right" : jc;
+  return ctx.schema.nodes["table"].create(
+    Object.keys(attrs).length > 0 ? attrs : null,
+    rows.length > 0 ? rows : [ctx.schema.nodes["table_row"].create(null, [emptyCell(ctx)])]
+  );
+}
+function parseBlocks(parent, ctx) {
+  const blocks = [];
+  for (const node of unwrapSdt(parent.children)) {
+    if (node.name === "w:p") blocks.push(parseParagraph(node, ctx));
+    else if (node.name === "w:tbl") blocks.push(parseTable(node, ctx));
+  }
+  return blocks;
+}
+function parseColumns(sectPr) {
+  const cols = sectPr && child(sectPr, "w:cols");
+  const num = Number(attrOf(cols, "w:num") ?? "1");
+  const explicit = cols ? children(cols, "w:col").length : 0;
+  const count = Math.max(Number.isNaN(num) ? 1 : num, explicit, 1);
+  const spaceTw = Number(attrOf(cols, "w:space") ?? "720");
+  return { count, gap: twipsToPx(Number.isNaN(spaceTw) ? 720 : spaceTw) };
+}
+function sectionStartsNewPage(sectPr) {
+  return attrOf(child(sectPr, "w:type"), "w:val") !== "continuous";
+}
+function parseBodyBlocks(body, ctx) {
+  const blocks = [];
+  const sections = [];
+  let start = 0;
+  for (const node of unwrapSdt(body.children)) {
+    if (node.name === "w:p") {
+      blocks.push(parseParagraph(node, ctx));
+      const sectPr = child(child(node, "w:pPr"), "w:sectPr");
+      if (sectPr) {
+        sections.push({
+          blockCount: blocks.length - start,
+          columns: parseColumns(sectPr),
+          newPage: sectionStartsNewPage(sectPr)
+        });
+        start = blocks.length;
+      }
+    } else if (node.name === "w:tbl") {
+      blocks.push(parseTable(node, ctx));
+    }
+  }
+  const bodySectPr = child(body, "w:sectPr");
+  if (blocks.length > start || sections.length === 0) {
+    sections.push({
+      blockCount: blocks.length - start,
+      columns: parseColumns(bodySectPr),
+      newPage: sectionStartsNewPage(bodySectPr)
+    });
+  }
+  return { blocks, sections };
+}
+async function readPart(zip, path) {
+  const entry = zip.file(path);
+  return entry ? entry.async("string") : void 0;
+}
+async function readPartRels(zip, partPath) {
+  const slash = partPath.lastIndexOf("/");
+  const relsPath = `${partPath.slice(0, slash + 1)}_rels/${partPath.slice(slash + 1)}.rels`;
+  const xml = await readPart(zip, relsPath);
+  return xml ? parseXml(xml) : void 0;
+}
+async function buildNotesRegistry(zip) {
+  const bodies = { footnote: /* @__PURE__ */ new Map(), endnote: /* @__PURE__ */ new Map() };
+  const load = async (path, root, tag, into) => {
+    const xml = await readPart(zip, path);
+    if (!xml) return;
+    for (const note of children(child(parseXml(xml), root), tag)) {
+      const id = attrOf(note, "w:id");
+      const type = attrOf(note, "w:type");
+      if (id === void 0 || Number(id) < 1 || type && type !== "normal") continue;
+      into.set(id, note);
+    }
+  };
+  await load("word/footnotes.xml", "w:footnotes", "w:footnote", bodies.footnote);
+  await load("word/endnotes.xml", "w:endnotes", "w:endnote", bodies.endnote);
+  const reg = {
+    bodies,
+    refs: [],
+    counter: { footnote: 0, endnote: 0 },
+    ref(kind, id) {
+      const num = ++reg.counter[kind];
+      reg.refs.push({ kind, id, num });
+      return num;
+    }
+  };
+  return reg;
+}
+async function buildCommentsRegistry(zip) {
+  const defs = /* @__PURE__ */ new Map();
+  const paraToId = /* @__PURE__ */ new Map();
+  const xml = await readPart(zip, "word/comments.xml");
+  if (xml) {
+    for (const c of children(child(parseXml(xml), "w:comments"), "w:comment")) {
+      const id = Number(attrOf(c, "w:id"));
+      if (Number.isNaN(id)) continue;
+      const paraIds = children(c, "w:p").map((p) => attrOf(p, "w14:paraId")).filter((v) => !!v);
+      for (const pid of paraIds) paraToId.set(pid, id);
+      defs.set(id, {
+        author: attrOf(c, "w:author") ?? "",
+        date: attrOf(c, "w:date") ?? "",
+        body: c,
+        paraIds
+      });
+    }
+  }
+  const ext = /* @__PURE__ */ new Map();
+  const extXml = await readPart(zip, "word/commentsExtended.xml");
+  if (extXml) {
+    for (const ex of children(child(parseXml(extXml), "w15:commentsEx"), "w15:commentEx")) {
+      const paraId2 = attrOf(ex, "w15:paraId");
+      if (!paraId2) continue;
+      const done = attrOf(ex, "w15:done");
+      ext.set(paraId2, {
+        parentParaId: attrOf(ex, "w15:paraIdParent") ?? null,
+        done: done === "1" || done === "true"
+      });
+    }
+  }
+  return { defs, paraToId, ext, active: /* @__PURE__ */ new Set(), used: [] };
+}
+function collectText(node) {
+  if (node.name === "w:t") return node.text ?? "";
+  return node.children.map(collectText).join("");
+}
+function buildCommentsList(ctx) {
+  const out = [];
+  for (const id of ctx.comments.used) {
+    const def = ctx.comments.defs.get(id);
+    if (def) out.push({ id, author: def.author, date: def.date, text: collectText(def.body).trim() });
+  }
+  return out;
+}
+function commentBodyJSON(comment) {
+  const paras = children(comment, "w:p").map((p) => {
+    const text = collectText(p);
+    return commentSchema.node("paragraph", null, text ? [commentSchema.text(text)] : []);
+  });
+  return commentSchema.node("doc", null, paras.length ? paras : [commentSchema.node("paragraph")]).toJSON();
+}
+function buildCommentNodes(ctx) {
+  const { defs, paraToId, ext, used } = ctx.comments;
+  const usedSet = new Set(used);
+  const parentOf = /* @__PURE__ */ new Map();
+  const resolvedOf = /* @__PURE__ */ new Map();
+  for (const [id, def] of defs) {
+    const exEntry = def.paraIds.map((p) => ext.get(p)).find(Boolean);
+    const pid = exEntry?.parentParaId != null ? paraToId.get(exEntry.parentParaId) ?? null : null;
+    parentOf.set(id, pid === id ? null : pid);
+    resolvedOf.set(id, exEntry?.done ?? false);
+  }
+  const referenced = (id) => {
+    for (let cur = id, n = 0; cur != null && n < 100; cur = parentOf.get(cur) ?? null, n++)
+      if (usedSet.has(cur)) return true;
+    return false;
+  };
+  const ids = [...used.filter((id) => defs.has(id)), ...[...defs.keys()].filter((id) => !usedSet.has(id))];
+  const out = [];
+  for (const id of ids) {
+    const def = defs.get(id);
+    if (!def || !referenced(id)) continue;
+    const user = { id: def.author || "unknown", name: def.author || "Unknown" };
+    out.push({
+      id,
+      parentId: parentOf.get(id) ?? null,
+      user,
+      date: def.date,
+      body: commentBodyJSON(def.body),
+      resolved: resolvedOf.get(id) ?? false
+    });
+  }
+  return out;
+}
+function noteBlocks(note, num, ctx) {
+  const blocks = parseBlocks(note, ctx);
+  const marker = ctx.schema.text(`${num}. `, [ctx.schema.marks["vertAlign"].create({ value: "super" })]);
+  const first = blocks[0];
+  if (first && first.type.name === "paragraph") {
+    const kids = [marker];
+    first.forEach((k) => kids.push(k));
+    blocks[0] = ctx.schema.nodes["paragraph"].create(first.attrs, kids);
+  } else {
+    blocks.unshift(ctx.schema.nodes["paragraph"].create(null, [marker]));
+  }
+  return blocks;
+}
+function buildFootnotesMap(ctx) {
+  const out = {};
+  for (const { kind, id, num } of ctx.notes.refs) {
+    if (kind !== "footnote") continue;
+    const note = ctx.notes.bodies.footnote.get(id);
+    if (note) out[num] = storyDoc(ctx, noteBlocks(note, num, ctx), null);
+  }
+  return out;
+}
+function buildNotesSection(ctx) {
+  const endnotes = ctx.notes.refs.filter((r) => r.kind === "endnote");
+  if (endnotes.length === 0) return [];
+  const out = [
+    ctx.schema.nodes["paragraph"].create({ spacing: { before: 12 } }, [
+      ctx.schema.text("Ghi ch\xFA cu\u1ED1i", [ctx.schema.marks["strong"].create()])
+    ])
+  ];
+  for (const { id, num } of endnotes) {
+    const note = ctx.notes.bodies.endnote.get(id);
+    if (note) out.push(...noteBlocks(note, num, ctx));
+  }
+  return out;
+}
+function storyDoc(ctx, blocks, numbering, sections = null, comments = null) {
+  const attrs = {};
+  if (numbering) attrs["numbering"] = numbering;
+  if (sections) attrs["sections"] = sections;
+  if (comments && comments.length > 0) attrs["comments"] = comments;
+  return ctx.schema.nodes["doc"].create(
+    Object.keys(attrs).length > 0 ? attrs : null,
+    blocks.length > 0 ? blocks : [ctx.schema.nodes["paragraph"].create()]
+  );
+}
+async function extractMedia(zip) {
+  const media = /* @__PURE__ */ new Map();
+  for (const path of Object.keys(zip.files)) {
+    if (!path.startsWith("word/media/")) continue;
+    const entry = zip.file(path);
+    if (!entry || entry.dir) continue;
+    media.set(path, `data:${mimeOf(path)};base64,${await entry.async("base64")}`);
+  }
+  return media;
+}
+async function importDocx(input, opts) {
+  const zip = await JSZip.loadAsync(input);
+  const rawDocumentXml = await readPart(zip, "word/document.xml");
+  if (rawDocumentXml === void 0) {
+    throw new Error("bapbong-docx: word/document.xml not found in archive");
+  }
+  const stylesXml = await readPart(zip, "word/styles.xml");
+  const numberingXml = await readPart(zip, "word/numbering.xml");
+  const themeXml = await readPart(zip, "word/theme/theme1.xml");
+  const resolveTheme = buildThemeResolver(themeXml ? parseXml(themeXml) : void 0);
+  const styles = buildStyleRegistry(stylesXml ? parseXml(stylesXml) : void 0, resolveTheme);
+  const numberingRoot = numberingXml ? parseXml(numberingXml) : void 0;
+  const media = await extractMedia(zip);
+  const notes = await buildNotesRegistry(zip);
+  const comments = await buildCommentsRegistry(zip);
+  const makeCtx = (rels) => ({
+    styles,
+    numbering: buildNumbering(numberingRoot),
+    rels,
+    media,
+    resolveTheme,
+    notes,
+    comments,
+    schema: opts?.schema ?? schema
+  });
+  const docRels = await readPart(zip, "word/_rels/document.xml.rels");
+  const ctx = makeCtx(buildRels(docRels ? parseXml(docRels) : void 0));
+  const body = child(child(parseXml(rawDocumentXml), "w:document"), "w:body");
+  const parsed = body ? parseBodyBlocks(body, ctx) : { blocks: [], sections: [] };
+  const footnotes = buildFootnotesMap(ctx);
+  const endnoteBlocks = buildNotesSection(ctx);
+  const { sections } = parsed;
+  if (endnoteBlocks.length > 0 && sections.length > 0) {
+    sections[sections.length - 1].blockCount += endnoteBlocks.length;
+  }
+  const multiSection = sections.length > 1 || sections.some((s) => s.columns.count > 1);
+  const hasComments = !!ctx.schema.marks["comment"];
+  const doc = storyDoc(
+    ctx,
+    [...parsed.blocks, ...endnoteBlocks],
+    ctx.numbering.defs,
+    multiSection ? sections : null,
+    hasComments ? buildCommentNodes(ctx) : null
+  );
+  const headers = {};
+  const footers = {};
+  const sectPr = body ? child(body, "w:sectPr") : void 0;
+  if (sectPr) {
+    const collect = async (refName, store, root) => {
+      for (const ref of children(sectPr, refName)) {
+        const type = attrOf(ref, "w:type") ?? "default";
+        const rId = attrOf(ref, "r:id");
+        const target = rId ? ctx.rels.get(rId)?.target : void 0;
+        if (!target || store[type]) continue;
+        const partPath = `word/${target.replace(/^\/+/, "")}`;
+        const xml = await readPart(zip, partPath);
+        if (!xml) continue;
+        const partCtx = makeCtx(buildRels(await readPartRels(zip, partPath)));
+        const el = child(parseXml(xml), root);
+        store[type] = storyDoc(partCtx, el ? parseBlocks(el, partCtx) : [], ctx.numbering.defs);
+      }
+    };
+    await collect("w:headerReference", headers, "w:hdr");
+    await collect("w:footerReference", footers, "w:ftr");
+  }
+  const titlePg = sectPr ? isToggleOn(child(sectPr, "w:titlePg")) : false;
+  const settingsXml = await readPart(zip, "word/settings.xml");
+  const settings = settingsXml ? child(parseXml(settingsXml), "w:settings") : void 0;
+  const evenAndOdd = settings ? isToggleOn(child(settings, "w:evenAndOddHeaders")) : false;
+  return {
+    doc,
+    rawDocumentXml,
+    headers,
+    footers,
+    footnotes,
+    titlePg,
+    evenAndOdd,
+    comments: hasComments ? buildCommentsList(ctx) : [],
+    page: parsePageGeometry(sectPr),
+    raw: zip
+  };
+}
+function isToggleOn(el) {
+  if (!el) return false;
+  const val = attrOf(el, "w:val");
+  return val === void 0 || !["false", "0", "off"].includes(val);
+}
+function parsePageGeometry(sectPr) {
+  const A4 = {
+    width: 794,
+    height: 1123,
+    margin: { top: 96, right: 96, bottom: 96, left: 96 }
+  };
+  if (!sectPr) return A4;
+  const pgSz = child(sectPr, "w:pgSz");
+  const pgMar = child(sectPr, "w:pgMar");
+  const px = (el, attr, fallback) => {
+    const v = el && attrOf(el, attr);
+    return v === void 0 || v === null ? fallback : twipsToPx(Number(v));
+  };
+  let width = px(pgSz, "w:w", A4.width);
+  let height = px(pgSz, "w:h", A4.height);
+  if (attrOf(pgSz, "w:orient") === "landscape" && height > width) {
+    [width, height] = [height, width];
+  }
+  return {
+    width,
+    height,
+    margin: {
+      top: px(pgMar, "w:top", 96),
+      right: px(pgMar, "w:right", 96),
+      bottom: px(pgMar, "w:bottom", 96),
+      left: px(pgMar, "w:left", 96)
+    }
+  };
+}
+
+// packages/docx/src/lib/export.ts
+import JSZip2 from "jszip";
+import { commentSchema as commentSchema2 } from "@shadow-garden/bapbong-model";
+var W_NS = "http://schemas.openxmlformats.org/wordprocessingml/2006/main";
+var R_NS = "http://schemas.openxmlformats.org/officeDocument/2006/relationships";
+var WP_NS = "http://schemas.openxmlformats.org/drawingml/2006/wordprocessingDrawing";
+var A_NS = "http://schemas.openxmlformats.org/drawingml/2006/main";
+var PIC_NS = "http://schemas.openxmlformats.org/drawingml/2006/picture";
+var WPS_NS = "http://schemas.microsoft.com/office/word/2010/wordprocessingShape";
+var W14_NS = "http://schemas.microsoft.com/office/word/2010/wordml";
+var W15_NS = "http://schemas.microsoft.com/office/word/2012/wordml";
+var CT_NS = "http://schemas.openxmlformats.org/package/2006/content-types";
+var PR_NS = "http://schemas.openxmlformats.org/package/2006/relationships";
+var paraId = (id) => (268435456 + id).toString(16).toUpperCase();
+var pxToTwips = (px) => Math.round(px * 15);
+var pxToEmu = (px) => Math.round(px * 9525);
+var commentIdsOf = (node) => node.marks.find((m) => m.type.name === "comment")?.attrs["ids"] ?? [];
+var isInlineLeaf = (node) => node.isText || node.type.name === "image" || node.type.name === "hard_break";
+function esc(s) {
+  return s.replace(/[&<>"]/g, (c) => ({ "&": "&amp;", "<": "&lt;", ">": "&gt;", '"': "&quot;" })[c]);
+}
+var MIME_EXT = {
+  "image/png": "png",
+  "image/jpeg": "jpeg",
+  "image/jpg": "jpeg",
+  "image/gif": "gif",
+  "image/bmp": "bmp"
+};
+function runProps(marks) {
+  const byName = new Map(marks.map((m) => [m.type.name, m]));
+  const out = [];
+  const fam = byName.get("fontFamily")?.attrs["family"];
+  if (fam) out.push(`<w:rFonts w:ascii="${esc(fam)}" w:hAnsi="${esc(fam)}"/>`);
+  if (byName.has("strong")) out.push("<w:b/>");
+  if (byName.has("em")) out.push("<w:i/>");
+  if (byName.has("underline")) out.push('<w:u w:val="single"/>');
+  if (byName.has("strike")) out.push("<w:strike/>");
+  const color = byName.get("textColor")?.attrs["color"];
+  if (color) out.push(`<w:color w:val="${color.replace(/^#/, "")}"/>`);
+  const size = byName.get("fontSize")?.attrs["size"];
+  if (size != null) out.push(`<w:sz w:val="${Math.round(size * 2)}"/>`);
+  const hl = byName.get("highlight")?.attrs["color"];
+  if (hl) out.push(`<w:shd w:val="clear" w:color="auto" w:fill="${hl.replace(/^#/, "")}"/>`);
+  const va = byName.get("vertAlign")?.attrs["value"];
+  if (va) out.push(`<w:vertAlign w:val="${va === "sub" ? "subscript" : "superscript"}"/>`);
+  return out.length ? `<w:rPr>${out.join("")}</w:rPr>` : "";
+}
+function anchorXml(float, cx, cy, n, graphic) {
+  const dist = (k) => pxToEmu(float[k] ?? 0);
+  const hRel = float["hRel"] === "page" ? "page" : "column";
+  const vRel = float["vRel"] === "page" ? "page" : float["vRel"] === "margin" ? "margin" : "paragraph";
+  const posH = float["hAlign"] ? `<wp:align>${float["hAlign"]}</wp:align>` : `<wp:posOffset>${pxToEmu(float["hOffset"] ?? 0)}</wp:posOffset>`;
+  const posV = `<wp:posOffset>${pxToEmu(float["vOffset"] ?? 0)}</wp:posOffset>`;
+  const wrap = float["wrap"] === "topAndBottom" ? "<wp:wrapTopAndBottom/>" : float["wrap"] === "none" ? "<wp:wrapNone/>" : '<wp:wrapSquare wrapText="bothSides"/>';
+  return `<wp:anchor distT="${dist("distT")}" distB="${dist("distB")}" distL="${dist("distL")}" distR="${dist("distR")}" simplePos="0" relativeHeight="251658240" behindDoc="0" locked="0" layoutInCell="1" allowOverlap="1"><wp:simplePos x="0" y="0"/><wp:positionH relativeFrom="${hRel}">${posH}</wp:positionH><wp:positionV relativeFrom="${vRel}">${posV}</wp:positionV><wp:extent cx="${cx}" cy="${cy}"/><wp:effectExtent l="0" t="0" r="0" b="0"/>` + wrap + `<wp:docPr id="${n}" name="Shape ${n}"/><wp:cNvGraphicFramePr/>` + graphic + `</wp:anchor>`;
+}
+function rotAttr(node) {
+  const deg = Number(node.attrs["rotation"]) || 0;
+  return deg ? ` rot="${Math.round(deg * 6e4)}"` : "";
+}
+function shapeXml(node, ctx) {
+  const s = node.attrs["shape"];
+  const rot = rotAttr(node);
+  const n = ctx.nextId++;
+  const cx = pxToEmu(node.attrs["width"] ?? 0);
+  const cy = pxToEmu(node.attrs["height"] ?? 0);
+  const fill = s.fill ? `<a:solidFill><a:srgbClr val="${s.fill.replace(/^#/, "")}"/></a:solidFill>` : "<a:noFill/>";
+  const ln = s.stroke ? `<a:ln w="${pxToEmu(s.strokeWidth ?? 1)}"><a:solidFill><a:srgbClr val="${s.stroke.replace(/^#/, "")}"/></a:solidFill></a:ln>` : "<a:ln><a:noFill/></a:ln>";
+  const tb = node.attrs["textbox"];
+  const txbx = tb ? `<wps:txbx><w:txbxContent>${tb.paragraphs.map((json) => paragraphXml(node.type.schema.nodeFromJSON(json), ctx)).join("")}</w:txbxContent></wps:txbx>` : "";
+  const bodyPr = tb?.inset ? `<wps:bodyPr lIns="${pxToEmu(tb.inset.l)}" tIns="${pxToEmu(tb.inset.t)}" rIns="${pxToEmu(tb.inset.r)}" bIns="${pxToEmu(tb.inset.b)}"/>` : "<wps:bodyPr/>";
+  const graphic = `<a:graphic><a:graphicData uri="${WPS_NS}"><wps:wsp><wps:cNvSpPr${tb ? ' txBox="1"' : ""}/><wps:spPr><a:xfrm${rot}${s.flipV ? ' flipV="1"' : ""}><a:off x="0" y="0"/><a:ext cx="${cx}" cy="${cy}"/></a:xfrm><a:prstGeom prst="${s.kind}"><a:avLst/></a:prstGeom>${fill}${ln}</wps:spPr>${txbx}${bodyPr}</wps:wsp></a:graphicData></a:graphic>`;
+  const float = node.attrs["float"];
+  const body = float ? anchorXml(float, cx, cy, n, graphic) : `<wp:inline distT="0" distB="0" distL="0" distR="0"><wp:extent cx="${cx}" cy="${cy}"/><wp:docPr id="${n}" name="Shape ${n}"/>${graphic}</wp:inline>`;
+  return `<w:r><w:drawing>${body}</w:drawing></w:r>`;
+}
+function imageXml(node, ctx) {
+  if (node.attrs["shape"]) return shapeXml(node, ctx);
+  const src = String(node.attrs["src"] ?? "");
+  const m = /^data:([^;]+);base64,(.+)$/.exec(src);
+  if (!m) return "";
+  const ext = MIME_EXT[m[1].toLowerCase()] ?? "png";
+  ctx.exts.add(ext);
+  const n = ctx.nextId++;
+  const rid = `rId${n}`;
+  ctx.media.push({ path: `word/media/image${n}.${ext}`, base64: m[2] });
+  ctx.rels.push(`<Relationship Id="${rid}" Type="${R_NS}/image" Target="media/image${n}.${ext}"/>`);
+  const cx = pxToEmu(node.attrs["width"] ?? 96);
+  const cy = pxToEmu(node.attrs["height"] ?? 96);
+  return `<w:r><w:drawing><wp:inline distT="0" distB="0" distL="0" distR="0"><wp:extent cx="${cx}" cy="${cy}"/><wp:docPr id="${n}" name="Picture ${n}"/><a:graphic><a:graphicData uri="${PIC_NS}"><pic:pic><pic:nvPicPr><pic:cNvPr id="${n}" name="image${n}.${ext}"/><pic:cNvPicPr/></pic:nvPicPr><pic:blipFill><a:blip r:embed="${rid}"/><a:stretch><a:fillRect/></a:stretch></pic:blipFill><pic:spPr><a:xfrm${rotAttr(node)}><a:off x="0" y="0"/><a:ext cx="${cx}" cy="${cy}"/></a:xfrm><a:prstGeom prst="rect"><a:avLst/></a:prstGeom></pic:spPr></pic:pic></a:graphicData></a:graphic></wp:inline></w:drawing></w:r>`;
+}
+function inlineXml(node, ctx) {
+  if (node.type.name === "hard_break") return "<w:r><w:br/></w:r>";
+  if (node.type.name === "image") return imageXml(node, ctx);
+  if (node.isText) {
+    const fn = node.marks.find((m) => m.type.name === "footnote");
+    if (fn) return `<w:r>${runProps(node.marks)}<w:footnoteReference w:id="${fn.attrs["num"]}"/></w:r>`;
+    return `<w:r>${runProps(node.marks)}<w:t xml:space="preserve">${esc(node.text ?? "")}</w:t></w:r>`;
+  }
+  return "";
+}
+var linkHref = (node) => node.marks.find((m) => m.type.name === "link")?.attrs["href"] ?? null;
+function inlineUnit(node, ctx) {
+  const inner = inlineXml(node, ctx);
+  const href = linkHref(node);
+  if (!href || !inner) return inner;
+  if (href.startsWith("#")) return `<w:hyperlink w:anchor="${esc(href.slice(1))}">${inner}</w:hyperlink>`;
+  const n = ctx.nextId++;
+  ctx.rels.push(`<Relationship Id="rId${n}" Type="${R_NS}/hyperlink" Target="${esc(href)}" TargetMode="External"/>`);
+  return `<w:hyperlink r:id="rId${n}">${inner}</w:hyperlink>`;
+}
+function inlineContent(node, ctx) {
+  let out = "";
+  node.forEach((child2) => {
+    if (!isInlineLeaf(child2)) return;
+    const ids = commentIdsOf(child2).filter((id) => ctx.knownComments.has(id));
+    for (const id of ids) {
+      if (!ctx.openComments.has(id)) {
+        out += `<w:commentRangeStart w:id="${id}"/>`;
+        ctx.openComments.add(id);
+      }
+    }
+    out += inlineUnit(child2, ctx);
+    const here = ctx.runIdx++;
+    for (const id of [...ctx.openComments]) {
+      if (ctx.lastRun.get(id) === here) {
+        out += `<w:commentRangeEnd w:id="${id}"/><w:r><w:commentReference w:id="${id}"/></w:r>`;
+        ctx.openComments.delete(id);
+      }
+    }
+  });
+  return out;
+}
+function sectionSectPr(s) {
+  const type = `<w:type w:val="${s.newPage ? "nextPage" : "continuous"}"/>`;
+  const cols = s.columns.count > 1 ? `<w:cols w:num="${s.columns.count}" w:space="${pxToTwips(s.columns.gap)}"/>` : `<w:cols w:space="${pxToTwips(s.columns.gap)}"/>`;
+  return `<w:sectPr>${type}${cols}</w:sectPr>`;
+}
+function paraProps(node) {
+  const a = node.attrs;
+  const out = [];
+  const heading = a["heading"];
+  if (heading) out.push(`<w:pStyle w:val="Heading${heading}"/>`);
+  if (a["pageBreakBefore"]) out.push("<w:pageBreakBefore/>");
+  const list = a["list"];
+  if (list) out.push(`<w:numPr><w:ilvl w:val="${list.level}"/><w:numId w:val="${esc(list.numId)}"/></w:numPr>`);
+  const sp = a["spacing"];
+  if (sp) {
+    const at = [];
+    if (sp.before != null) at.push(`w:before="${pxToTwips(sp.before)}"`);
+    if (sp.after != null) at.push(`w:after="${pxToTwips(sp.after)}"`);
+    if (sp.line != null) {
+      const auto = sp.lineRule === "auto" || sp.lineRule == null;
+      at.push(`w:line="${auto ? Math.round(sp.line * 240) : pxToTwips(sp.line)}"`);
+      at.push(`w:lineRule="${sp.lineRule ?? "auto"}"`);
+    }
+    if (at.length) out.push(`<w:spacing ${at.join(" ")}/>`);
+  }
+  const ind = a["indent"];
+  if (ind) {
+    const at = [];
+    if (ind.left != null) at.push(`w:left="${pxToTwips(ind.left)}"`);
+    if (ind.right != null) at.push(`w:right="${pxToTwips(ind.right)}"`);
+    if (ind.hanging != null) at.push(`w:hanging="${pxToTwips(ind.hanging)}"`);
+    else if (ind.firstLine != null) at.push(`w:firstLine="${pxToTwips(ind.firstLine)}"`);
+    if (at.length) out.push(`<w:ind ${at.join(" ")}/>`);
+  }
+  const align = a["align"];
+  if (align) out.push(`<w:jc w:val="${align === "justify" ? "both" : align}"/>`);
+  return out.join("");
+}
+function paragraphXml(node, ctx, sectPr = "") {
+  const props = paraProps(node) + sectPr;
+  const pPr = props ? `<w:pPr>${props}</w:pPr>` : "";
+  return `<w:p>${pPr}${inlineContent(node, ctx)}</w:p>`;
+}
+var TABLE_SIDES2 = ["top", "bottom", "left", "right", "insideH", "insideV"];
+var CELL_SIDES2 = ["top", "bottom", "left", "right"];
+var BORDER_STYLE_OUT = {
+  solid: "single",
+  dashed: "dashed",
+  dotted: "dotted",
+  double: "double"
+};
+function bordersXml(tag, borders, sides) {
+  const inner = sides.filter((s) => s in borders).map((s) => {
+    const side = borders[s];
+    if (!side) return `<w:${s} w:val="nil"/>`;
+    const sz = Math.max(2, Math.round(side.width * 6));
+    const color = side.color === "#b0b0b0" ? "auto" : side.color.replace(/^#/, "");
+    return `<w:${s} w:val="${BORDER_STYLE_OUT[side.style] ?? "single"}" w:sz="${sz}" w:space="0" w:color="${color}"/>`;
+  }).join("");
+  return inner ? `<${tag}>${inner}</${tag}>` : "";
+}
+function cellXml(cell, ctx) {
+  const a = cell.attrs;
+  const pr = [];
+  const colwidth = a["colwidth"];
+  if (colwidth?.length) pr.push(`<w:tcW w:w="${pxToTwips(colwidth.reduce((x, y) => x + y, 0))}" w:type="dxa"/>`);
+  if (a["colspan"] > 1) pr.push(`<w:gridSpan w:val="${a["colspan"]}"/>`);
+  const borders = a["borders"];
+  if (borders) pr.push(bordersXml("w:tcBorders", borders, CELL_SIDES2));
+  const bg = a["background"];
+  if (bg) pr.push(`<w:shd w:val="clear" w:color="auto" w:fill="${bg.replace(/^#/, "")}"/>`);
+  const vAlign = a["vAlign"];
+  if (vAlign) pr.push(`<w:vAlign w:val="${vAlign}"/>`);
+  let content = "";
+  cell.forEach((b) => content += blockXml(b, ctx));
+  if (!content) content = "<w:p/>";
+  return `<w:tc><w:tcPr>${pr.join("")}</w:tcPr>${content}</w:tc>`;
+}
+function rowXml(row, ctx) {
+  const pr = [];
+  if (row.attrs["header"]) pr.push("<w:tblHeader/>");
+  if (row.attrs["cantSplit"]) pr.push("<w:cantSplit/>");
+  const h = row.attrs["height"];
+  if (h) pr.push(`<w:trHeight w:val="${pxToTwips(h.value)}" w:hRule="${h.exact ? "exact" : "atLeast"}"/>`);
+  const trPr = pr.length ? `<w:trPr>${pr.join("")}</w:trPr>` : "";
+  let cells = "";
+  row.forEach((c) => cells += cellXml(c, ctx));
+  return `<w:tr>${trPr}${cells}</w:tr>`;
+}
+function tableXml(node, ctx) {
+  const a = node.attrs;
+  const pr = [];
+  if (a["align"]) pr.push(`<w:jc w:val="${a["align"]}"/>`);
+  const borders = a["borders"];
+  if (borders) pr.push(bordersXml("w:tblBorders", borders, TABLE_SIDES2));
+  const pad = a["cellPadding"];
+  if (pad) {
+    const m = ["top", "left", "bottom", "right"].filter((s) => pad[s] != null).map((s) => `<w:${s} w:w="${pxToTwips(pad[s])}" w:type="dxa"/>`).join("");
+    if (m) pr.push(`<w:tblCellMar>${m}</w:tblCellMar>`);
+  }
+  const firstRow = node.firstChild;
+  const grid = [];
+  firstRow?.forEach((c) => c.attrs["colwidth"]?.forEach((w) => grid.push(w)));
+  const gridXml = grid.length ? `<w:tblGrid>${grid.map((w) => `<w:gridCol w:w="${pxToTwips(w)}"/>`).join("")}</w:tblGrid>` : "";
+  let rows = "";
+  node.forEach((r) => rows += rowXml(r, ctx));
+  return `<w:tbl><w:tblPr>${pr.join("")}</w:tblPr>${gridXml}${rows}</w:tbl>`;
+}
+function blockXml(node, ctx, sectPr = "") {
+  if (node.type.name === "paragraph") return paragraphXml(node, ctx, sectPr);
+  let out = node.type.name === "table" ? tableXml(node, ctx) : "";
+  if (sectPr) out += `<w:p><w:pPr>${sectPr}</w:pPr></w:p>`;
+  return out;
+}
+function sectionBoundaries(doc) {
+  const sections = doc.attrs["sections"];
+  const out = /* @__PURE__ */ new Map();
+  if (!sections || sections.length < 2) return out;
+  let acc = 0;
+  for (let i = 0; i < sections.length - 1; i++) {
+    acc += sections[i].blockCount;
+    out.set(acc - 1, sectionSectPr(sections[i]));
+  }
+  return out;
+}
+function commentBodyXml(body, firstParaId) {
+  let doc = null;
+  try {
+    doc = commentSchema2.nodeFromJSON(body);
+  } catch {
+    doc = null;
+  }
+  if (!doc) return `<w:p w14:paraId="${firstParaId}"/>`;
+  const ps = [];
+  doc.forEach((p, _o, i) => {
+    let runs = "";
+    p.forEach((inline) => {
+      if (inline.isText) runs += `<w:r><w:t xml:space="preserve">${esc(inline.text ?? "")}</w:t></w:r>`;
+      else if (inline.type.name === "mention") runs += `<w:r><w:t xml:space="preserve">@${esc(String(inline.attrs["label"] ?? ""))}</w:t></w:r>`;
+    });
+    ps.push(`<w:p${i === 0 ? ` w14:paraId="${firstParaId}"` : ""}>${runs}</w:p>`);
+  });
+  return ps.join("") || `<w:p w14:paraId="${firstParaId}"/>`;
+}
+var initialsOf = (name) => name.trim().split(/\s+/).map((w) => w[0] ?? "").join("").slice(0, 3).toUpperCase();
+function commentsXml(comments) {
+  const body = comments.map(
+    (c) => `<w:comment w:id="${c.id}" w:author="${esc(c.user.name)}" w:date="${esc(c.date)}" w:initials="${esc(initialsOf(c.user.name))}">${commentBodyXml(c.body, paraId(c.id))}</w:comment>`
+  ).join("");
+  return `<?xml version="1.0" encoding="UTF-8" standalone="yes"?>
+<w:comments xmlns:w="${W_NS}" xmlns:w14="${W14_NS}">${body}</w:comments>`;
+}
+function commentsExtendedXml(comments) {
+  const body = comments.map((c) => {
+    const parent = c.parentId != null ? ` w15:paraIdParent="${paraId(c.parentId)}"` : "";
+    return `<w15:commentEx w15:paraId="${paraId(c.id)}"${parent} w15:done="${c.resolved ? 1 : 0}"/>`;
+  }).join("");
+  return `<?xml version="1.0" encoding="UTF-8" standalone="yes"?>
+<w15:commentsEx xmlns:w15="${W15_NS}">${body}</w15:commentsEx>`;
+}
+var ROOT_RELS = `<?xml version="1.0" encoding="UTF-8" standalone="yes"?>
+<Relationships xmlns="${PR_NS}"><Relationship Id="rId1" Type="${R_NS}/officeDocument" Target="word/document.xml"/></Relationships>`;
+function contentTypes(exts, hasComments) {
+  const parts = [
+    '<Default Extension="rels" ContentType="application/vnd.openxmlformats-package.relationships+xml"/>',
+    '<Default Extension="xml" ContentType="application/xml"/>'
+  ];
+  for (const ext of exts) parts.push(`<Default Extension="${ext}" ContentType="image/${ext === "jpg" ? "jpeg" : ext}"/>`);
+  parts.push('<Override PartName="/word/document.xml" ContentType="application/vnd.openxmlformats-officedocument.wordprocessingml.document.main+xml"/>');
+  if (hasComments) {
+    parts.push('<Override PartName="/word/comments.xml" ContentType="application/vnd.openxmlformats-officedocument.wordprocessingml.comments+xml"/>');
+    parts.push('<Override PartName="/word/commentsExtended.xml" ContentType="application/vnd.openxmlformats-officedocument.wordprocessingml.commentsExtended+xml"/>');
+  }
+  return `<?xml version="1.0" encoding="UTF-8" standalone="yes"?>
+<Types xmlns="${CT_NS}">${parts.join("")}</Types>`;
+}
+function mergeContentTypes(xml, exts, hasComments) {
+  let out = xml;
+  const add = (frag, key) => {
+    if (!out.includes(`"${key}"`)) out = out.replace("</Types>", `${frag}</Types>`);
+  };
+  for (const ext of exts) add(`<Default Extension="${ext}" ContentType="image/${ext === "jpg" ? "jpeg" : ext}"/>`, ext);
+  if (hasComments) {
+    add('<Override PartName="/word/comments.xml" ContentType="application/vnd.openxmlformats-officedocument.wordprocessingml.comments+xml"/>', "/word/comments.xml");
+    add('<Override PartName="/word/commentsExtended.xml" ContentType="application/vnd.openxmlformats-officedocument.wordprocessingml.commentsExtended+xml"/>', "/word/commentsExtended.xml");
+  }
+  return out;
+}
+function extractBodySectPr(xml) {
+  const all = xml.match(/<w:sectPr\b[^>]*>[\s\S]*?<\/w:sectPr>|<w:sectPr\b[^>]*\/>/g);
+  return all ? all[all.length - 1] : "";
+}
+function mergeRels(xml, newRels) {
+  const base = (xml ?? `<?xml version="1.0" encoding="UTF-8" standalone="yes"?>
+<Relationships xmlns="${PR_NS}"></Relationships>`).replace(
+    /<Relationship\b[^>]*Target="comments(?:Extended)?\.xml"[^>]*\/>/g,
+    ""
+  );
+  return base.replace("</Relationships>", `${newRels.join("")}</Relationships>`);
+}
+async function exportDocx(doc, opts) {
+  const comments = doc.attrs["comments"] ?? [];
+  const knownComments = new Set(comments.map((c) => c.id));
+  const lastRun = /* @__PURE__ */ new Map();
+  let idx = 0;
+  doc.descendants((n) => {
+    if (!isInlineLeaf(n)) return;
+    for (const id of commentIdsOf(n)) if (knownComments.has(id)) lastRun.set(id, idx);
+    idx++;
+  });
+  const ctx = {
+    rels: [],
+    media: [],
+    exts: /* @__PURE__ */ new Set(),
+    nextId: 100,
+    knownComments,
+    lastRun,
+    openComments: /* @__PURE__ */ new Set(),
+    runIdx: 0
+  };
+  const boundaries = sectionBoundaries(doc);
+  let body = "";
+  doc.forEach((block, _offset, i) => body += blockXml(block, ctx, boundaries.get(i)));
+  const hasComments = comments.length > 0;
+  if (hasComments) {
+    ctx.rels.push(`<Relationship Id="rIdComments" Type="${R_NS}/comments" Target="comments.xml"/>`);
+    ctx.rels.push(`<Relationship Id="rIdCommentsExt" Type="${R_NS}/commentsExtended" Target="commentsExtended.xml"/>`);
+  }
+  const zip = new JSZip2();
+  let sectPr = "";
+  if (opts?.carry) {
+    const carry = opts.carry;
+    for (const [path, f] of Object.entries(carry.files)) {
+      if (!f.dir) zip.file(path, await f.async("uint8array"));
+    }
+    const ct = await carry.file("[Content_Types].xml")?.async("string");
+    zip.file("[Content_Types].xml", ct ? mergeContentTypes(ct, ctx.exts, hasComments) : contentTypes(ctx.exts, hasComments));
+    const rels = await carry.file("word/_rels/document.xml.rels")?.async("string");
+    zip.file("word/_rels/document.xml.rels", mergeRels(rels, ctx.rels));
+    const origDoc = await carry.file("word/document.xml")?.async("string");
+    if (origDoc) sectPr = extractBodySectPr(origDoc);
+  } else {
+    zip.file("[Content_Types].xml", contentTypes(ctx.exts, hasComments));
+    zip.file("_rels/.rels", ROOT_RELS);
+    if (ctx.rels.length) {
+      zip.file("word/_rels/document.xml.rels", `<?xml version="1.0" encoding="UTF-8" standalone="yes"?>
+<Relationships xmlns="${PR_NS}">${ctx.rels.join("")}</Relationships>`);
+    }
+  }
+  const documentXml = `<?xml version="1.0" encoding="UTF-8" standalone="yes"?>
+<w:document xmlns:w="${W_NS}" xmlns:r="${R_NS}" xmlns:wp="${WP_NS}" xmlns:a="${A_NS}" xmlns:pic="${PIC_NS}" xmlns:wps="${WPS_NS}"><w:body>${body}${sectPr}</w:body></w:document>`;
+  zip.file("word/document.xml", documentXml);
+  if (hasComments) {
+    zip.file("word/comments.xml", commentsXml(comments));
+    zip.file("word/commentsExtended.xml", commentsExtendedXml(comments));
+  }
+  for (const { path, base64 } of ctx.media) zip.file(path, base64, { base64: true });
+  return zip.generateAsync({ type: "uint8array" });
+}
+export {
+  exportDocx,
+  importDocx
+};