@forevka/wordcanvas 0.8.1 → 0.9.0

package/dist-lib/query.js

@@ -0,0 +1,977 @@
+import { t as C, B as v, f as Q, a as X, D as Z, c as O, n as tt, e as dt, h as z, j as ft, k as ut, l as F, r as et } from "./toc-B-TzD-Mr.js";
+import { r as nt, c as ht } from "./engine-Chvebzwr.js";
+import { c as pt } from "./lists-BVCy5dMa.js";
+import { r as mt } from "./stylesheet-IH4Hyc8o.js";
+function _(o, t, e, n, s = []) {
+  for (const r of o)
+    if (n(r, t), e.cells && r.kind === "table")
+      for (let i = 0; i < r.rows.length; i++) {
+        const c = r.rows[i].cells;
+        for (let l = 0; l < c.length; l++) {
+          const d = { tableId: r.id, row: i, col: l }, a = [...s, d], f = { ...t, cell: d };
+          a.length >= 2 && (f.cellPath = a), _(c[l].blocks, f, e, n, a);
+        }
+      }
+}
+function k(o, t, e = {}) {
+  const n = { bands: !0, notes: !0, cells: !0, ...e };
+  if (_(o.blocks, { container: "body" }, n, t), n.bands) {
+    for (const s of v) {
+      const r = o.section[s];
+      r && _(r, { container: s }, n, t);
+    }
+    for (const s of o.blocks)
+      if (!(s.kind !== "paragraph" || !s.style.sectionBreak))
+        for (const r of v) {
+          const i = s.style.sectionBreak.props[r];
+          i && _(i, { container: r }, n, t);
+        }
+  }
+  if (n.notes) {
+    for (const [s, r] of Object.entries(o.footnotes ?? {}))
+      _(r, { container: "body", note: { kind: "footnote", id: s } }, n, t);
+    for (const [s, r] of Object.entries(o.endnotes ?? {}))
+      _(r, { container: "body", note: { kind: "endnote", id: s } }, n, t);
+  }
+}
+function ot(o) {
+  return o.blocks.map(V).filter((t) => t.length > 0).join(`
+`);
+}
+function Vt(o, t, e) {
+  k(o, (n, s) => {
+    n.kind === "paragraph" && n.runs.forEach((r, i) => {
+      t(r, { ...s, block: n, runIndex: i, sdtChain: Q(n, r.style) });
+    });
+  }, e);
+}
+function V(o) {
+  switch (o.kind) {
+    case "paragraph":
+      return C(o.runs);
+    case "table":
+      return o.rows.map((t) => t.cells.map(ot).join("	")).join(`
+`);
+    default:
+      return "";
+  }
+}
+function Kt(o, t) {
+  const e = [];
+  return k(o, (n) => {
+    n.kind === "paragraph" && e.push(n);
+  }, t), e;
+}
+function Yt(o, t) {
+  const e = [];
+  return k(o, (n) => {
+    n.kind === "table" && e.push(n);
+  }, t), e;
+}
+function qt(o, t) {
+  const e = [];
+  return k(o, (n) => {
+    n.kind === "image" && e.push(n);
+  }, t), e;
+}
+function yt(o, t, e) {
+  const n = typeof t == "string" ? (r) => r.includes(t) : (r) => (t.lastIndex = 0, t.test(r)), s = [];
+  return k(o, (r, i) => {
+    if (r.kind !== "paragraph") return;
+    const c = C(r.runs);
+    n(c) && s.push({ paragraph: r, text: c, context: i });
+  }, e), s;
+}
+function R(o, t, e) {
+  let n;
+  return k(o, (s) => {
+    n === void 0 && s.id === t && (n = s);
+  }, e), n;
+}
+function L(o, t, e) {
+  const n = R(o, t, e);
+  return n?.kind === "paragraph" ? n : void 0;
+}
+function G(o, t, e) {
+  const n = R(o, t, e);
+  return n?.kind === "table" ? n : void 0;
+}
+function Wt(o, t, e) {
+  const n = R(o, t, e);
+  return n?.kind === "image" ? n : void 0;
+}
+function zt(o) {
+  return nt(o);
+}
+function x(o, t) {
+  return o.sdts?.[t];
+}
+function st(o) {
+  return Object.entries(o.sdts ?? {}).map(([t, e]) => ({ id: t, props: e }));
+}
+function Gt(o, t) {
+  return st(o).filter((e) => e.props.tag === t);
+}
+function Jt(o, t) {
+  return st(o).filter((e) => e.props.alias === t);
+}
+function gt(o) {
+  const t = /* @__PURE__ */ new Map(), e = /* @__PURE__ */ new Map(), n = /* @__PURE__ */ new Set(), s = (r) => {
+    if (!(!r || r.length < 2))
+      for (let i = 1; i < r.length; i++) {
+        const c = r[i - 1], l = r[i];
+        t.has(l) || t.set(l, c);
+        const d = `${c}\0${l}`;
+        if (n.has(d)) continue;
+        n.add(d);
+        const a = e.get(c) ?? [];
+        a.push(l), e.set(c, a);
+      }
+  };
+  return k(o, (r) => {
+    if (s(r.sdtPath), r.kind === "paragraph")
+      for (const i of r.runs) s(Q(r, i.style));
+  }), { parentOf: t, childrenOf: e };
+}
+function N(o) {
+  const t = o.sdts ?? {}, e = (c) => Object.prototype.hasOwnProperty.call(t, c), { parentOf: n, childrenOf: s } = gt(o), r = (c) => {
+    const l = [c], d = /* @__PURE__ */ new Set([c]);
+    for (let a = n.get(c); a !== void 0 && e(a) && !d.has(a); a = n.get(a))
+      l.unshift(a), d.add(a);
+    return l;
+  }, i = /* @__PURE__ */ new Map();
+  for (const [c, l] of Object.entries(t)) {
+    const d = n.get(c), a = d !== void 0 && e(d) ? d : void 0, f = (s.get(c) ?? []).filter(e), u = r(c);
+    i.set(c, {
+      id: c,
+      props: l,
+      ...a !== void 0 ? { parentId: a } : {},
+      childIds: f,
+      path: u,
+      depth: u.length - 1
+    });
+  }
+  return i;
+}
+function kt(o) {
+  return [...N(o).values()];
+}
+function Qt(o) {
+  return kt(o).filter((t) => t.parentId === void 0);
+}
+function Xt(o, t) {
+  const e = N(o), n = e.get(t);
+  return n ? n.childIds.map((s) => e.get(s)).filter((s) => s !== void 0) : [];
+}
+function Zt(o, t) {
+  const e = N(o), n = e.get(t);
+  return n ? n.path.slice(0, -1).map((s) => e.get(s)).filter((s) => s !== void 0) : [];
+}
+function te(o, t) {
+  const e = N(o), n = [], s = (r) => {
+    for (const i of e.get(r)?.childIds ?? []) {
+      const c = e.get(i);
+      c && (n.push(c), s(i));
+    }
+  };
+  return e.has(t) && s(t), n;
+}
+function bt(o, t, e) {
+  const n = [];
+  return k(o, (s) => {
+    s.sdtPath?.includes(t) && n.push(s);
+  }, e), n;
+}
+function wt(o, t, e) {
+  const n = [];
+  return k(o, (s) => {
+    if (s.sdtPath?.includes(t)) {
+      const r = V(s);
+      r.length > 0 && n.push(r);
+      return;
+    }
+    if (s.kind === "paragraph") {
+      const r = s.runs.filter((i) => i.style.sdtPath?.includes(t));
+      r.length > 0 && n.push(C(r));
+    }
+  }, e), n.join(`
+`);
+}
+function ee(o, t) {
+  const e = o.sdts?.[t];
+  if (!e) return;
+  const n = { type: e.type, text: wt(o, t) };
+  if (e.type === "checkbox" && (n.checked = e.checked ?? !1), e.type === "dropDown" || e.type === "comboBox") {
+    const s = e.listItems?.find((r) => r.display === n.text);
+    s ? n.selected = s.value : e.type === "comboBox" && (n.selected = n.text);
+  }
+  return n;
+}
+function ne(o, t) {
+  return o.fields?.[t];
+}
+function St(o) {
+  return Object.values(o.fields ?? {});
+}
+function oe(o, t) {
+  const e = t.toUpperCase();
+  return St(o).filter((n) => n.name.toUpperCase() === e);
+}
+function se(o, t, e) {
+  const n = [];
+  return k(o, (s) => {
+    s.fieldId === t && n.push(s);
+  }, e), n;
+}
+function re(o, t) {
+  return o.bookmarks?.[t];
+}
+function ie(o) {
+  return Object.entries(o.bookmarks ?? {}).map(([t, e]) => ({ name: t, range: e }));
+}
+function ce(o) {
+  return Object.entries(o.footnotes ?? {}).map(([t, e]) => ({ id: t, paragraphs: e }));
+}
+function ae(o) {
+  return Object.entries(o.endnotes ?? {}).map(([t, e]) => ({ id: t, paragraphs: e }));
+}
+function le(o, t) {
+  const e = o.lists?.[t], n = [], s = [];
+  return k(o, (r, i) => {
+    if (r.kind !== "paragraph") return;
+    const c = r.style.list;
+    if (!c || c.listId !== t) return;
+    const l = e?.levels[Math.min(c.level, e.levels.length - 1)];
+    n[c.level] = (n[c.level] ?? (l?.start ?? 1) - 1) + 1, n.length = c.level + 1;
+    const d = e ? pt(e, c.level, n) : "";
+    s.push({ paragraph: r, level: c.level, marker: d, context: i });
+  }, { bands: !1, notes: !1 }), s;
+}
+function de(o) {
+  return o.stylesheet?.styles ?? [];
+}
+function fe(o, t) {
+  return o.stylesheet?.styles.find((e) => e.id === t);
+}
+function ue(o, t, e) {
+  let n;
+  return k(o, (s, r) => {
+    n === void 0 && s.id === t && (n = r);
+  }, e), n;
+}
+function J(o) {
+  return o.kind === "paragraph" ? C(o.runs) : V(o);
+}
+function he(o, t) {
+  const { anchor: e, focus: n } = t;
+  if (e.blockId === n.blockId) {
+    const u = R(o, e.blockId);
+    if (!u) return "";
+    const p = Math.min(e.offset, n.offset), P = Math.max(e.offset, n.offset);
+    return J(u).slice(p, P);
+  }
+  const s = new Map(o.blocks.map((u, p) => [u.id, p])), r = s.get(e.blockId), i = s.get(n.blockId);
+  if (r === void 0 || i === void 0) return "";
+  const [c, l, d, a] = r <= i ? [e, n, r, i] : [n, e, i, r], f = [];
+  for (let u = d; u <= a; u++) {
+    const p = J(o.blocks[u]);
+    u === d ? f.push(p.slice(c.offset)) : u === a ? f.push(p.slice(0, l.offset)) : f.push(p);
+  }
+  return f.join(`
+`);
+}
+function pe(o, t, e) {
+  let n;
+  return k(o, (s) => {
+    if (n !== void 0 || s.kind !== "paragraph") return;
+    const r = C(s.runs).indexOf(t);
+    r >= 0 && (n = { blockId: s.id, offset: r });
+  }, e), n;
+}
+function K(o, t) {
+  if (!t.has(o)) return o;
+  let e = 2;
+  for (; t.has(`${o}__${e}`); ) e++;
+  return `${o}__${e}`;
+}
+const g = (o, t) => o.get(t) ?? t;
+function E(o, t) {
+  for (const e of o)
+    if (t.set(e.id, O()), e.kind === "table")
+      for (const n of e.rows) for (const s of n.cells) E(s.blocks, t);
+    else if (e.kind === "paragraph" && e.style.sectionBreak)
+      for (const n of v) {
+        const s = e.style.sectionBreak.props[n];
+        s && E(s, t);
+      }
+}
+function Pt(o, t) {
+  const e = { ...o };
+  return e.sdtPath && (e.sdtPath = tt(e.sdtPath.map((n) => g(t.sdts, n)))), e.fieldId && (e.fieldId = g(t.fields, e.fieldId)), e.footnoteRef && (e.footnoteRef = g(t.footnotes, e.footnoteRef)), e.endnoteRef && (e.endnoteRef = g(t.endnotes, e.endnoteRef)), e.charStyleId && (e.charStyleId = g(t.styles, e.charStyleId)), e;
+}
+function U(o, t) {
+  return { text: o.text, style: Pt(o.style, t) };
+}
+function It(o, t) {
+  const e = { ...o };
+  return e.namedStyle && (e.namedStyle = g(t.styles, e.namedStyle)), e.list && (e.list = { ...e.list, listId: g(t.lists, e.list.listId) }), e.tocEntry && (e.tocEntry = { ...e.tocEntry, targetId: g(t.blocks, e.tocEntry.targetId) }), e.sectionBreak && (e.sectionBreak = { type: e.sectionBreak.type, props: Bt(e.sectionBreak.props, t) }), e;
+}
+function Bt(o, t) {
+  const e = { ...o };
+  for (const n of v) {
+    const s = e[n];
+    s && (e[n] = s.map((r) => $(r, t)));
+  }
+  return e;
+}
+function D(o, t) {
+  return o ? tt(o.map((e) => g(t, e))) : void 0;
+}
+function vt(o, t) {
+  return { ...o, id: O(), blocks: o.blocks.map((e) => $(e, t)) };
+}
+function xt(o, t) {
+  return { ...o, cells: o.cells.map((e) => vt(e, t)) };
+}
+function $(o, t) {
+  const e = g(t.blocks, o.id);
+  switch (o.kind) {
+    case "paragraph": {
+      const n = { ...o, id: e, runs: o.runs.map((s) => U(s, t)), style: It(o.style, t) };
+      return n.fieldId && (n.fieldId = g(t.fields, n.fieldId)), n.sdtPath = D(o.sdtPath, t.sdts), n;
+    }
+    case "image": {
+      const n = { ...o, id: e };
+      return n.fieldId && (n.fieldId = g(t.fields, n.fieldId)), n.sdtPath = D(o.sdtPath, t.sdts), n;
+    }
+    case "table": {
+      const n = { ...o, id: e, rows: o.rows.map((s) => xt(s, t)) };
+      return n.styleId && (n.styleId = g(t.tableStyles, n.styleId)), n.fieldId && (n.fieldId = g(t.fields, n.fieldId)), n.sdtPath = D(o.sdtPath, t.sdts), n;
+    }
+    case "equation": {
+      const n = { ...o, id: e };
+      return n.fieldId && (n.fieldId = g(t.fields, n.fieldId)), n.sdtPath = D(o.sdtPath, t.sdts), n;
+    }
+  }
+}
+function _t(o, t, e) {
+  const n = { ...o, id: t };
+  return n.spec?.type === "IF" && (n.spec = {
+    ...n.spec,
+    trueRuns: n.spec.trueRuns.map((s) => U(s, e)),
+    falseRuns: n.spec.falseRuns.map((s) => U(s, e))
+  }), n;
+}
+function Et(o, t) {
+  const e = { ...o };
+  for (const n of v) {
+    const s = e[n];
+    s && (e[n] = s.map((r) => $(r, t)));
+  }
+  return e;
+}
+function Ot(o) {
+  const t = {
+    pageWidthPx: o.pageWidthPx,
+    pageHeightPx: o.pageHeightPx,
+    marginPx: o.marginPx,
+    columns: o.columns ?? null
+  };
+  o.pageNumberStart !== void 0 && (t.pageNumberStart = o.pageNumberStart), o.pageColorHex !== void 0 && (t.pageColorHex = o.pageColorHex), o.pageBorders !== void 0 && (t.pageBorders = o.pageBorders), o.headerDistancePx !== void 0 && (t.headerDistancePx = o.headerDistancePx), o.footerDistancePx !== void 0 && (t.footerDistancePx = o.footerDistancePx), o.lineNumbering !== void 0 && (t.lineNumbering = o.lineNumbering);
+  for (const e of v) t[e] = o[e] ?? [];
+  return t;
+}
+function $t(o, t) {
+  return {
+    kind: "paragraph",
+    id: O(),
+    revision: 0,
+    runs: [{ text: "", style: { ...Z } }],
+    style: { ...X, sectionBreak: { type: t, props: Ot(o) } }
+  };
+}
+function rt(o, t, e, n, s, r) {
+  const i = o.map((a) => ({ ...a })), c = new Set(i.map((a) => a.id)), l = new Map(i.map((a) => [a.name, a.id])), d = [];
+  for (const a of t) {
+    if (e === "useDestination") {
+      const u = l.get(a.name);
+      if (u !== void 0) {
+        n.set(a.id, u);
+        continue;
+      }
+    }
+    let f = a.id;
+    c.has(f) && (f = K(a.id, c), s.push({ code: r, detail: `${a.id} → ${f}` })), c.add(f), n.set(a.id, f), d.push({ ...a, id: f });
+  }
+  for (const a of d) a.basedOn !== void 0 && (a.basedOn = g(n, a.basedOn));
+  return i.push(...d), i;
+}
+function Mt(o, t, e, n, s) {
+  return t ? { styles: rt(o?.styles ?? [], t.styles, e, n, s, "style-id-renamed"), defaultStyleId: o?.defaultStyleId ?? t.defaultStyleId } : o;
+}
+function Tt(o, t, e, n, s) {
+  const r = rt(Object.values(o ?? {}), Object.values(t ?? {}), e, n, s, "table-style-id-renamed"), i = {};
+  for (const c of r) i[c.id] = c;
+  return i;
+}
+function T(o, t, e) {
+  const n = { ...o ?? {} }, s = new Set(Object.keys(n));
+  for (const r of Object.keys(t ?? {})) {
+    let i = r;
+    s.has(i) && (i = K(r, s)), s.add(i), e.set(r, i);
+  }
+  return n;
+}
+function it() {
+  return { blocks: {}, styles: {}, lists: {}, tableStyles: {}, sdts: {}, fields: {}, footnotes: {}, endnotes: {}, bookmarks: {} };
+}
+function ct(o, t, e = {}) {
+  const n = e.styles ?? "useDestination", s = e.renameBookmarksOnCollision ?? !0, r = [], i = /* @__PURE__ */ new Map();
+  E(t.blocks, i);
+  for (const h of v) {
+    const y = t.section[h];
+    y && E(y, i);
+  }
+  for (const h of Object.values(t.footnotes ?? {})) E(h, i);
+  for (const h of Object.values(t.endnotes ?? {})) E(h, i);
+  const c = /* @__PURE__ */ new Map(), l = Mt(o.stylesheet, t.stylesheet, n, c, r), d = /* @__PURE__ */ new Map(), a = T(o.lists, t.lists, d);
+  for (const [h, y] of d) a[y] = { ...t.lists[h], id: y };
+  const f = /* @__PURE__ */ new Map(), u = Tt(o.tableStyles, t.tableStyles, n, f, r), p = /* @__PURE__ */ new Map(), P = T(o.sdts, t.sdts, p);
+  for (const [h, y] of p) P[y] = { ...t.sdts[h] };
+  const I = /* @__PURE__ */ new Map();
+  T(o.fields, t.fields, I);
+  const B = /* @__PURE__ */ new Map(), m = { ...o.footnotes ?? {} };
+  T(o.footnotes, t.footnotes, B);
+  const b = /* @__PURE__ */ new Map(), j = { ...o.endnotes ?? {} };
+  T(o.endnotes, t.endnotes, b);
+  const M = {
+    blocks: i,
+    styles: c,
+    lists: d,
+    tableStyles: f,
+    sdts: p,
+    fields: I,
+    footnotes: B,
+    endnotes: b
+  }, Y = { ...o.fields ?? {} };
+  for (const [h, y] of I) Y[y] = _t(t.fields[h], y, M);
+  for (const [h, y] of B) m[y] = t.footnotes[h].map((w) => $(w, M));
+  for (const [h, y] of b) j[y] = t.endnotes[h].map((w) => $(w, M));
+  const q = (h) => ({ blockId: g(i, h.blockId), offset: h.offset }), W = /* @__PURE__ */ new Map(), A = { ...o.bookmarks ?? {} }, H = new Set(Object.keys(A));
+  for (const [h, y] of Object.entries(t.bookmarks ?? {})) {
+    let w = h;
+    if (H.has(w)) {
+      if (!s) {
+        r.push({ code: "bookmark-dropped", detail: h });
+        continue;
+      }
+      w = K(h, H), r.push({ code: "bookmark-renamed", detail: `${h} → ${w}` });
+    }
+    H.add(w), W.set(h, w), A[w] = { start: q(y.start), end: q(y.end) };
+  }
+  const S = (h) => Object.fromEntries(h);
+  return {
+    stylesheet: l,
+    lists: a,
+    tableStyles: u,
+    sdts: P,
+    fields: Y,
+    footnotes: m,
+    endnotes: j,
+    bookmarks: A,
+    sourceBlocks: t.blocks.map((h) => $(h, M)),
+    sourceSection: Et(t.section, M),
+    idMap: {
+      blocks: S(i),
+      styles: S(c),
+      lists: S(d),
+      tableStyles: S(f),
+      sdts: S(p),
+      fields: S(I),
+      footnotes: S(B),
+      endnotes: S(b),
+      bookmarks: S(W)
+    },
+    warnings: r
+  };
+}
+function at(o, t, e, n) {
+  const s = { section: e, blocks: n };
+  return t.stylesheet && (s.stylesheet = t.stylesheet), Object.keys(t.lists).length && (s.lists = t.lists), Object.keys(t.tableStyles).length && (s.tableStyles = t.tableStyles), Object.keys(t.footnotes).length && (s.footnotes = t.footnotes), Object.keys(t.endnotes).length && (s.endnotes = t.endnotes), Object.keys(t.sdts).length && (s.sdts = t.sdts), Object.keys(t.bookmarks).length && (s.bookmarks = t.bookmarks), Object.keys(t.fields).length && (s.fields = t.fields), o.tocInstruction !== void 0 && (s.tocInstruction = o.tocInstruction), o.tocAnchorBlockId !== void 0 && (s.tocAnchorBlockId = o.tocAnchorBlockId), o.defaultTabStopPx !== void 0 && (s.defaultTabStopPx = o.defaultTabStopPx), o.compatSettings && (s.compatSettings = o.compatSettings), s;
+}
+function lt(o, t, e = {}) {
+  const n = e.sectionBreak ?? "nextPage";
+  if (t.blocks.length === 0)
+    return { doc: { ...o }, idMap: it(), warnings: [{ code: "empty-source" }] };
+  const s = ct(o, t, e);
+  let r, i;
+  return o.blocks.length === 0 ? (r = s.sourceBlocks, i = s.sourceSection) : n === "continuous" || n === "none" ? (r = [...o.blocks, ...s.sourceBlocks], i = o.section, s.warnings.push({ code: "source-section-dropped", detail: n })) : (r = [...o.blocks, $t(o.section, n), ...s.sourceBlocks], i = s.sourceSection), { doc: at(o, s, i, r), idMap: s.idMap, warnings: s.warnings };
+}
+function me(o, t = {}) {
+  if (o.length === 0) throw new Error("mergeAll requires at least one document");
+  let e = o[0], n = it();
+  const s = [];
+  for (let r = 1; r < o.length; r++) {
+    const i = lt(e, o[r], t);
+    e = i.doc, n = i.idMap, s.push(...i.warnings);
+  }
+  return { doc: e, idMap: n, warnings: s };
+}
+const Ct = ["sectionBreak", "pageBreakBefore", "columnBreakBefore", "tocEntry"];
+class ye {
+  _doc;
+  undoStack = [];
+  redoStack = [];
+  constructor(t) {
+    this._doc = t;
+  }
+  /** The current document. Every edit swaps this for a new immutable value
+   *  (structural sharing), so a captured reference is a stable snapshot. */
+  get doc() {
+    return this._doc;
+  }
+  get canUndo() {
+    return this.undoStack.length > 0;
+  }
+  get canRedo() {
+    return this.redoStack.length > 0;
+  }
+  // --- editing ----------------------------------------------------------------
+  /** Replace all runs of a paragraph with a single run of `text`. `style`
+   *  defaults to the paragraph's current first-run style. */
+  setParagraphText(t, e, n) {
+    const s = this.mustParagraph(t), r = [];
+    if (e.length > 0) {
+      const i = n ?? s.runs[0]?.style;
+      if (!i) throw new Error(`setParagraphText: paragraph ${t} is empty; pass a style`);
+      r.push({ text: e, style: i });
+    }
+    return this.commit([{ type: "setRuns", blockId: t, runs: r }]);
+  }
+  /** Insert `text` at a UTF-16 offset within a paragraph. */
+  insertText(t, e, n, s) {
+    return this.commit([{ type: "insertText", at: { blockId: t, offset: e }, text: n, ...s ? { style: s } : {} }]);
+  }
+  /** Delete the UTF-16 range [start, end) within a paragraph. */
+  deleteText(t, e, n) {
+    return this.commit([{ type: "deleteRange", blockId: t, start: e, end: n }]);
+  }
+  /** Replace the UTF-16 range [start, end) within a paragraph with `text`
+   *  (delete + insert as one undoable step). */
+  replaceText(t, e, n, s, r) {
+    const i = [{ type: "deleteRange", blockId: t, start: e, end: n }];
+    return s.length > 0 && i.push({ type: "insertText", at: { blockId: t, offset: e }, text: s, ...r ? { style: r } : {} }), this.commit(i);
+  }
+  /** Patch a paragraph's style (alignment, indents, spacing, list, borders…). */
+  setParagraphStyle(t, e) {
+    return this.commit([{ type: "setParaStyle", blockId: t, patch: e }]);
+  }
+  /** Remove a top-level block (paragraph, table, image…) by id. */
+  removeBlock(t) {
+    return this.commit([{ type: "removeBlock", blockId: t }]);
+  }
+  /** Insert a new paragraph before/after a top-level reference block. Returns the
+   *  new paragraph's id via `lastInsertedId`. */
+  insertParagraph(t, e, n = {}) {
+    const s = dt(this._doc, t);
+    if (!s) throw new Error(`insertParagraph: ${t} is not a top-level block`);
+    const r = R(this._doc, t), i = r?.kind === "paragraph" ? r : void 0, c = n.style ?? (i ? Rt(i.style) : void 0);
+    if (!c) throw new Error(`insertParagraph: reference ${t} is not a paragraph; pass options.style`);
+    const l = n.runStyle ?? i?.runs[0]?.style;
+    if (e.length > 0 && !l) throw new Error("insertParagraph: no run style available; pass options.runStyle");
+    const d = O(), a = {
+      kind: "paragraph",
+      id: d,
+      revision: 0,
+      runs: e.length > 0 ? [{ text: e, style: l }] : [],
+      style: c
+    }, f = n.position === "before" ? s.index : s.index + 1;
+    return this._lastInsertedId = d, this.commit([{ type: "insertBlock", index: f, block: a, where: s.where }]);
+  }
+  _lastInsertedId = null;
+  /** The id minted by the most recent `insertParagraph`, or null. */
+  get lastInsertedId() {
+    return this._lastInsertedId;
+  }
+  // --- content controls (SDTs) — the primary templating surface ---------------
+  /** Merge a patch onto a content control's properties (alias, tag, checked,
+   *  listItems, date format, locks…). The control must already exist. The control
+   *  `type` is the discriminant for how it round-trips and paints, so it is NOT
+   *  patchable here — it is always preserved (excluded from the patch shape and
+   *  re-forced on the merge, even against an untyped runtime caller). */
+  setSdtProps(t, e) {
+    const n = x(this._doc, t);
+    if (!n) throw new Error(`setSdtProps: content control ${t} not found`);
+    const s = { ...n, ...e, type: n.type };
+    return this.commit([{ type: "setSdtProps", id: t, props: s }]);
+  }
+  /** Set a checkbox content control's state (☒/☐). Throws if `id` is not a
+   *  checkbox control. */
+  setCheckbox(t, e) {
+    const n = x(this._doc, t);
+    if (!n) throw new Error(`setCheckbox: content control ${t} not found`);
+    if (n.type !== "checkbox")
+      throw new Error(`setCheckbox: ${t} is a "${n.type}" control, not a checkbox`);
+    return this.setSdtProps(t, { checked: e });
+  }
+  /** Replace the text of a content control that occupies a SINGLE paragraph —
+   *  either an inline control (runs tagged with `id`) or a block-level control
+   *  wrapping one paragraph. The killer templating primitive: "fill this field".
+   *  Preserves the control's ancestry (so nesting survives) and clears any
+   *  placeholder flag. Throws for controls spanning multiple blocks (edit those by
+   *  block id) or not found. */
+  setSdtText(t, e) {
+    const n = x(this._doc, t);
+    if (!n) throw new Error(`setSdtText: content control ${t} not found`);
+    const s = bt(this._doc, t);
+    if (s.length > 0) {
+      if (s.length > 1 || s[0].kind !== "paragraph")
+        throw new Error(`setSdtText: ${t} spans ${s.length} block(s); edit multi-block controls by block id`);
+      const u = s[0], p = u.runs[0]?.style;
+      if (e.length > 0 && !p)
+        throw new Error(`setSdtText: block control ${t} is empty; cannot infer a run style`);
+      const P = e.length > 0 ? [{ text: e, style: p }] : [];
+      return this.commit(this.withPlaceholderCleared(t, n, [{ type: "setRuns", blockId: u.id, runs: P }]));
+    }
+    const r = this.locateInlineSdt(t);
+    if (!r) throw new Error(`setSdtText: content control ${t} has no editable text region`);
+    const { para: i, from: c, to: l, baseStyle: d } = r, a = { ...d, sdtPath: z(d.sdtPath, t) ?? [t] }, f = [
+      ...i.runs.slice(0, c),
+      ...e.length > 0 ? [{ text: e, style: a }] : [],
+      ...i.runs.slice(l)
+    ];
+    return this.commit(this.withPlaceholderCleared(t, n, [{ type: "setRuns", blockId: i.id, runs: f }]));
+  }
+  /** Select a value on a dropDown/comboBox content control — the "choose an
+   *  option" primitive. `value` matches a listItem by its VALUE first, then by its
+   *  display; the control's text becomes that item's display. A comboBox accepts
+   *  free text (no match ⇒ `value` is used verbatim); a dropDown requires a listed
+   *  option (throws otherwise). For other control kinds use `setSdtText`/`setCheckbox`. */
+  setSdtValue(t, e) {
+    const n = x(this._doc, t);
+    if (!n) throw new Error(`setSdtValue: content control ${t} not found`);
+    if (n.type !== "dropDown" && n.type !== "comboBox")
+      throw new Error(`setSdtValue: ${t} is a "${n.type}" control; use setSdtText or setCheckbox`);
+    const s = n.listItems ?? [], r = s.find((i) => i.value === e) ?? s.find((i) => i.display === e);
+    if (!r && n.type === "dropDown")
+      throw new Error(`setSdtValue: "${e}" is not an option of dropdown ${t}`);
+    return this.setSdtText(t, r ? r.display : e);
+  }
+  /** Remove a content control, UNWRAPPING it: strip its id from every member run
+   *  (inline) and body block (block-level) path — so NESTED controls survive — and
+   *  delete its properties, keeping the "every path id has a props entry" invariant.
+   *  With `deleteContents: true` the wrapped content is deleted too. Inline controls
+   *  are handled in any story (body, cells, bands, notes); block-level controls are
+   *  handled at the TOP LEVEL of the body — a block-level control nested in a table
+   *  cell, band, or note throws (remove it by block id). */
+  removeSdt(t, e = {}) {
+    if (!x(this._doc, t)) throw new Error(`removeSdt: content control ${t} not found`);
+    const s = e.deleteContents ?? !1, r = new Map(this._doc.blocks.map((a, f) => [a.id, f])), i = [], c = [];
+    let l;
+    if (k(this._doc, (a, f) => {
+      a.sdtPath?.includes(t) ? f.container === "body" && !f.cell && !f.note && r.has(a.id) ? c.push(a) : l ??= f.note ? "a note body" : f.cell ? "a table cell" : `the ${f.container} band` : a.kind === "paragraph" && a.runs.some((u) => u.style.sdtPath?.includes(t)) && i.push(a.id);
+    }), l)
+      throw new Error(`removeSdt: ${t} has a block-level member in ${l}; not supported — remove it by block id`);
+    const d = [];
+    for (const a of i) {
+      const f = L(this._doc, a), u = s ? f.runs.filter((p) => !p.style.sdtPath?.includes(t)) : f.runs.map((p) => p.style.sdtPath?.includes(t) ? jt(p, t) : p);
+      d.push({ type: "setRuns", blockId: a, runs: u });
+    }
+    for (const a of c.slice().sort((f, u) => r.get(u.id) - r.get(f.id))) {
+      const f = r.get(a.id);
+      d.push({ type: "removeBlock", blockId: a.id }), s || d.push({ type: "insertBlock", index: f, block: Dt(a, t), where: "body" });
+    }
+    return d.push({ type: "setSdtProps", id: t, props: null }), this.commit(d);
+  }
+  // --- ergonomic bulk / structural edits --------------------------------------
+  /** Find/replace across every paragraph in the document as ONE undoable step.
+   *  A string replaces ALL occurrences; a RegExp is applied per run (pass the `g`
+   *  flag to replace all). Replacement happens WITHIN each run — matches that span
+   *  a style boundary are not replaced (a deliberate limit so run styling is always
+   *  preserved). Returns `this`. */
+  replaceAllText(t, e) {
+    const n = [];
+    return k(this._doc, (s) => {
+      if (s.kind !== "paragraph") return;
+      let r = !1;
+      const i = s.runs.map((c) => {
+        const l = typeof t == "string" ? c.text.split(t).join(e) : c.text.replace(t, e);
+        return l !== c.text && (r = !0), l === c.text ? c : { ...c, text: l };
+      });
+      r && n.push({ type: "setRuns", blockId: s.id, runs: i });
+    }), this.commit(n);
+  }
+  /** Apply a named paragraph style by its human NAME (e.g. "Heading 1"), resolving
+   *  it to a styleId via the stylesheet and BAKING the resolved paragraph + run
+   *  formatting onto the block (the model is concrete), plus setting the `namedStyle`
+   *  reference. Throws if the document has no stylesheet or no style with that name. */
+  setStyleByName(t, e) {
+    const n = this._doc.stylesheet, s = n?.styles.find((l) => l.name === e);
+    if (!n || !s) throw new Error(`setStyleByName: no style named "${e}"`);
+    const r = this.mustParagraph(t), i = mt(n, s.id), c = [{ type: "setParaStyle", blockId: t, patch: { ...i.para, namedStyle: s.id } }];
+    if (Object.keys(i.char).length > 0 && r.runs.length > 0) {
+      const l = r.runs.reduce((d, a) => d + a.text.length, 0);
+      c.push({ type: "setRuns", blockId: t, runs: ft(r.runs, 0, l, i.char) });
+    }
+    return this.commit(c);
+  }
+  /** Move a top-level BODY block to a new index among the body blocks (remove +
+   *  insert as one undoable step). `toIndex` is the destination among the OTHER
+   *  blocks (after removal), clamped to range. Throws if the block is not a
+   *  top-level body block. */
+  moveBlock(t, e) {
+    const n = this._doc.blocks.findIndex((i) => i.id === t);
+    if (n === -1) throw new Error(`moveBlock: ${t} is not a top-level body block`);
+    const s = this._doc.blocks[n], r = Math.max(0, Math.min(e, this._doc.blocks.length - 1));
+    return r === n ? this : this.commit([
+      { type: "removeBlock", blockId: t },
+      { type: "insertBlock", index: r, block: s, where: "body" }
+    ]);
+  }
+  /** Insert a row into a table at `rowIndex` (clamped). `cellTexts` fills the new
+   *  cells left-to-right (missing/extra entries pad/trim to the table's column
+   *  count); omit for an empty row. New cells inherit a run style from an existing
+   *  table paragraph (or the document default). */
+  insertTableRowAt(t, e, n = []) {
+    const s = G(this._doc, t);
+    if (!s) throw new Error(`insertTableRowAt: table ${t} not found`);
+    const r = s.rows.length > 0 ? ut(s) : Math.max(1, n.length), i = Nt(s.rows) ?? Z, c = Array.from({ length: r }, (d, a) => {
+      const f = n[a] ?? "", u = {
+        kind: "paragraph",
+        id: O(),
+        revision: 0,
+        runs: f.length > 0 ? [{ text: f, style: i }] : [],
+        style: { ...X }
+      };
+      return { id: O(), blocks: [u] };
+    }), l = Math.max(0, Math.min(e, s.rows.length));
+    return this.commit([{ type: "insertTableRow", tableId: t, rowIndex: l, row: { cells: c } }]);
+  }
+  /** Delete the column whose header (first-row cell text) equals `headerText`.
+   *  Throws if the table or a matching header is not found. */
+  deleteColumnByHeader(t, e) {
+    const n = G(this._doc, t);
+    if (!n) throw new Error(`deleteColumnByHeader: table ${t} not found`);
+    const s = n.rows[0], r = s ? s.cells.findIndex((i) => ot(i) === e) : -1;
+    if (r === -1) throw new Error(`deleteColumnByHeader: no column headed "${e}" in table ${t}`);
+    return this.commit([{ type: "removeTableColumn", tableId: t, colIndex: r }]);
+  }
+  /** Find the single paragraph holding the contiguous run span tagged with the
+   *  inline control `id`, plus that span `[from, to)` and its base run style. */
+  locateInlineSdt(t) {
+    let e;
+    return k(this._doc, (n) => {
+      if (e || n.kind !== "paragraph") return;
+      let s = -1, r = -1;
+      n.runs.forEach((i, c) => {
+        i.style.sdtPath?.includes(t) && (s === -1 && (s = c), r = c + 1);
+      }), s !== -1 && (e = { para: n, from: s, to: r, baseStyle: n.runs[s].style });
+    }), e;
+  }
+  /** Append a `setSdtProps` op clearing a placeholder flag, when set — so filling
+   *  a control drops its gray placeholder styling, like the interactive editor. */
+  withPlaceholderCleared(t, e, n) {
+    return e.placeholder ? [...n, { type: "setSdtProps", id: t, props: { ...e, placeholder: !1 } }] : n;
+  }
+  // --- undo / redo ------------------------------------------------------------
+  /** Undo the most recent edit. Returns false when there's nothing to undo. */
+  undo() {
+    const t = this.undoStack.pop();
+    if (!t) return !1;
+    let e = this._doc;
+    for (const n of t.inverse) e = F(e, n).doc;
+    return this._doc = e, this.redoStack.push(t), !0;
+  }
+  /** Redo the most recently undone edit. Returns false when there's nothing to redo. */
+  redo() {
+    const t = this.redoStack.pop();
+    if (!t) return !1;
+    let e = this._doc;
+    for (const n of t.forward) e = F(e, n).doc;
+    return this._doc = e, this.undoStack.push(t), !0;
+  }
+  /** Append another document's content after this one — the headless equivalent of
+   *  Word's "insert file at end". Reconciles every id space (see mergeDocuments) and
+   *  lands as ONE undoable step. Returns the merge's id map + warnings; the merged
+   *  document becomes `this.doc`. */
+  append(t, e = {}) {
+    const n = lt(this._doc, t, e);
+    return this.commit([{ type: "setDocument", doc: n.doc }]), n;
+  }
+  /** Replace a block-level content control's entire content with another document —
+   *  the templating primitive: find control `sdtId`, drop what's inside it, and splice
+   *  in `sourceDoc`'s blocks, reconciling every id space (styles, lists, table styles,
+   *  content controls, fields, notes, bookmarks — see mergeDocuments). The control's
+   *  ancestry is preserved and PREPENDED onto the inserted blocks, so the source's own
+   *  nested controls survive nested inside this one. One undoable step; returns the
+   *  merge's id map + warnings.
+   *
+   *  The control must be a BLOCK-LEVEL control at the TOP LEVEL of the body. A control
+   *  inside a table cell / header-footer band / note body, or an inline (single-run)
+   *  control, throws — use `setSdtText` to fill an inline control. */
+  replaceSdtContent(t, e, n = {}) {
+    if (!x(this._doc, t)) throw new Error(`replaceSdtContent: content control ${t} not found`);
+    const s = new Map(this._doc.blocks.map((m, b) => [m.id, b])), r = [];
+    let i, c, l = !1;
+    if (k(this._doc, (m, b) => {
+      m.sdtPath?.includes(t) ? b.container === "body" && !b.cell && !b.note && s.has(m.id) ? (r.push(m.id), i ??= z(m.sdtPath, t)) : c ??= b.note ? "a note body" : b.cell ? "a table cell" : `the ${b.container} band` : m.kind === "paragraph" && m.runs.some((j) => j.style.sdtPath?.includes(t)) && (l = !0);
+    }), l) throw new Error(`replaceSdtContent: ${t} is an inline control; use setSdtText`);
+    if (c) throw new Error(`replaceSdtContent: ${t} has a block-level member in ${c}; not supported`);
+    if (r.length === 0) throw new Error(`replaceSdtContent: ${t} has no block-level content in the body`);
+    const d = ct(this._doc, e, n), a = d.sdts[t];
+    a?.placeholder && (d.sdts[t] = { ...a, placeholder: !1 });
+    const f = i ?? [t], u = d.sourceBlocks.map((m) => ({ ...m, sdtPath: [...f, ...m.sdtPath ?? []] })), p = new Set(r), P = s.get(r[0]), I = [];
+    this._doc.blocks.forEach((m, b) => {
+      b === P && I.push(...u), p.has(m.id) || I.push(m);
+    });
+    const B = at(this._doc, d, this._doc.section, I);
+    return this.commit([{ type: "setDocument", doc: B }]), { doc: B, idMap: d.idMap, warnings: d.warnings };
+  }
+  /** Set (or clear, with `null`) a header/footer band on a specific section by its
+   *  index (see resolveSections / getSections). The final/body section stores its
+   *  bands on the document; a mid-document section stores them on its break
+   *  paragraph. Pairs with `append` for a post-merge per-section footer pass. One
+   *  undoable step. Throws if `sectionIndex` is out of range. */
+  setSectionBand(t, e, n) {
+    const s = nt(this._doc);
+    if (t < 0 || t >= s.length)
+      throw new Error(`section ${t} out of range (0..${s.length - 1})`);
+    if (t === s.length - 1)
+      return this.commit([{ type: "setSectionBand", band: e, blocks: n }]);
+    const r = this._doc.blocks[s[t].endBlock];
+    if (!r || r.kind !== "paragraph" || !r.style.sectionBreak)
+      throw new Error(`section ${t} has no section-break paragraph to carry a band`);
+    const i = r.style.sectionBreak, c = { ...i.props };
+    return n ? c[e] = n : delete c[e], this.commit([{ type: "setParaStyle", blockId: r.id, patch: { sectionBreak: { type: i.type, props: c } } }]);
+  }
+  /** Set (or clear) a section's default footer band. See `setSectionBand`. */
+  setSectionFooter(t, e) {
+    return this.setSectionBand(t, "footer", e);
+  }
+  /** Set (or clear) a section's default header band. See `setSectionBand`. */
+  setSectionHeader(t, e) {
+    return this.setSectionBand(t, "header", e);
+  }
+  // --- convenience queries ----------------------------------------------------
+  /** Find paragraphs by text (see query.findParagraphs). */
+  find(t) {
+    return yt(this._doc, t);
+  }
+  /** The paragraph with this id, or undefined. */
+  getParagraph(t) {
+    return L(this._doc, t);
+  }
+  // --- internals --------------------------------------------------------------
+  mustParagraph(t) {
+    const e = L(this._doc, t);
+    if (!e) throw new Error(`paragraph ${t} not found`);
+    return e;
+  }
+  /** Apply a list of ops as ONE undoable commit, clearing the redo stack. */
+  commit(t) {
+    if (t.length === 0) return this;
+    const e = [];
+    let n = this._doc;
+    for (const s of t) {
+      const r = F(n, s);
+      n = r.doc, e.unshift(r.inverse);
+    }
+    return this._doc = n, this.undoStack.push({ forward: t, inverse: e }), this.redoStack.length = 0, this;
+  }
+}
+function Rt(o) {
+  const t = { ...o }, e = t;
+  for (const n of Ct) delete e[n];
+  return t;
+}
+function jt(o, t) {
+  const e = et(o.style.sdtPath, t), n = { ...o.style };
+  return e ? n.sdtPath = e : delete n.sdtPath, { ...o, style: n };
+}
+function Dt(o, t) {
+  const e = et(o.sdtPath, t), n = { ...o, revision: o.revision + 1 }, s = n;
+  return e ? s.sdtPath = e : delete s.sdtPath, n;
+}
+function Nt(o) {
+  for (const t of o)
+    for (const e of t.cells)
+      for (const n of e.blocks)
+        if (n.kind === "paragraph" && n.runs[0]) return n.runs[0].style;
+}
+function At(o, t = {}) {
+  return ht(t.fontRegistry, t.engineOptions).layout(o).pages.map((s) => {
+    const r = /* @__PURE__ */ new Set(), i = [];
+    for (const l of s.blocks)
+      r.has(l.blockId) || (r.add(l.blockId), i.push(l.blockId));
+    const c = {
+      index: s.index,
+      number: s.number,
+      widthPx: s.widthPx,
+      heightPx: s.heightPx,
+      marginPx: s.marginPx,
+      contentTopPx: s.contentTopPx,
+      contentBottomPx: s.contentBottomPx,
+      blockIds: i
+    };
+    return s.pageColorHex !== void 0 && (c.pageColorHex = s.pageColorHex), c;
+  });
+}
+function ge(o, t, e) {
+  for (const n of At(o, e))
+    if (n.blockIds.includes(t)) return n.number;
+  return null;
+}
+function ke(o, t) {
+  for (const e of o) {
+    const n = e.blockIds.indexOf(t);
+    if (n >= 0) return { index: e.index, order: n };
+  }
+  return null;
+}
+export {
+  ye as DocumentEditor,
+  ue as blockPath,
+  yt as findParagraphs,
+  R as getBlockById,
+  re as getBookmark,
+  ie as getBookmarks,
+  ae as getEndnotes,
+  ne as getField,
+  se as getFieldBlocks,
+  St as getFields,
+  oe as getFieldsByName,
+  ce as getFootnotes,
+  Wt as getImageById,
+  qt as getImages,
+  le as getListItems,
+  At as getPages,
+  L as getParagraphById,
+  Kt as getParagraphs,
+  x as getSdt,
+  Zt as getSdtAncestors,
+  bt as getSdtBlocks,
+  Xt as getSdtChildren,
+  te as getSdtDescendants,
+  kt as getSdtNodes,
+  Qt as getSdtRoots,
+  ee as getSdtValue,
+  st as getSdts,
+  Jt as getSdtsByAlias,
+  Gt as getSdtsByTag,
+  zt as getSections,
+  fe as getStyleById,
+  de as getStyles,
+  G as getTableById,
+  Yt as getTables,
+  ke as indexOnPage,
+  me as mergeAll,
+  lt as mergeDocuments,
+  ge as pageOfBlock,
+  pe as positionOfText,
+  he as rangeText,
+  nt as resolveSections,
+  wt as sdtText,
+  V as textOf,
+  k as walk,
+  Vt as walkRuns
+};