@forevka/wordcanvas 0.8.1 → 0.9.0

package/dist-node/chunk-HMBQQDXD.js.map

@@ -1,7 +0,0 @@
-{
-  "version": 3,
-  "sources": ["../../shared/src/model/text.ts", "../../shared/src/model/lists.ts", "../../shared/src/model/sdt.ts", "../../shared/src/model/defaults.ts", "../../shared/src/model/ops.ts", "../../shared/src/ids.ts", "../../shared/src/toc.ts", "../../shared/src/model/stylesheet.ts", "../../shared/src/model/math.ts", "../../shared/src/fields.ts", "../../shared/src/fieldEval.ts"],
-  "sourcesContent": ["// Shared text helpers over the model: paragraph text access, grapheme/word\r\n// boundaries (Intl.Segmenter \u2014 the same segmentation pretext breaks lines on),\r\n// and style-at-position for Word-style inheritance when typing.\r\n\r\nimport type { BandContainer, Block, CharStyle, Document, Paragraph, Run } from \"./document\";\r\nimport { BAND_CONTAINERS } from \"./document\";\r\n\r\nexport const graphemes = new Intl.Segmenter(undefined, { granularity: \"grapheme\" });\r\nexport const words = new Intl.Segmenter(undefined, { granularity: \"word\" });\r\n\r\n/** Step-0 perf diagnostic (off by default, ~free when disabled). When `enabled`,\r\n *  paragraphsOf/bandParagraphs tally how often they rebuild the paragraph list and\r\n *  how many paragraph slots they walk+allocate \u2014 the exact work a WeakMap index\r\n *  keyed on document identity would eliminate. Toggle via the export, read the\r\n *  counters, reset between workloads. Used by frontend/src/perf/readsPerDoc.test.ts. */\r\nexport const _paraScanStats = {\r\n  enabled: false,\r\n  /** # of full-document traversals (paragraphsOf calls). */\r\n  fullCalls: 0,\r\n  /** Sum of full-list lengths returned (body + band paragraphs walked). */\r\n  fullSlots: 0,\r\n  /** # of bandParagraphs calls (incl. the O(N\u00B2) isBandParagraph filter). */\r\n  bandCalls: 0,\r\n  /** Sum of band-list lengths walked. */\r\n  bandSlots: 0,\r\n};\r\nexport const resetParaScanStats = (): void => {\r\n  _paraScanStats.fullCalls = 0;\r\n  _paraScanStats.fullSlots = 0;\r\n  _paraScanStats.bandCalls = 0;\r\n  _paraScanStats.bandSlots = 0;\r\n};\r\n\r\n/** A paragraph whose every non-empty run is hidden (w:vanish): it has text but\r\n *  none is visible. Such a paragraph is never laid out, caret-reachable, or\r\n *  deletable \u2014 it's preserved metadata. A truly empty paragraph (no text at all)\r\n *  is NOT hidden \u2014 it's a normal blank line. */\r\nexport const isHiddenParagraph = (p: Paragraph): boolean =>\r\n  p.runs.some((r) => r.text.length > 0) && p.runs.every((r) => r.text.length === 0 || r.style.hidden === true);\r\n\r\nconst paragraphsInBlocks = (blocks: Block[], includeCells: boolean): Paragraph[] => {\r\n  const out: Paragraph[] = [];\r\n  for (const b of blocks) {\r\n    if (b.kind === \"paragraph\") out.push(b);\r\n    else if (b.kind === \"table\" && includeCells) {\r\n      for (const row of b.rows) {\r\n        for (const cell of row.cells) out.push(...paragraphsInBlocks(cell.blocks, includeCells));\r\n      }\r\n    }\r\n  }\r\n  return out;\r\n};\r\n\r\n/** The two band STORIES from the UI's point of view (story mode is entered per\r\n *  header/footer area; which variant CONTAINER that resolves to depends on the\r\n *  page \u2014 see Page.headerSource/footerSource). */\r\nexport type BandName = \"header\" | \"footer\";\r\n\r\n/** Editable paragraphs of a margin band container, document order \u2014 INCLUDING\r\n *  band-table cells (imported footers are routinely tables holding text next\r\n *  to a page-number paragraph). */\r\nexport const bandParagraphs = (doc: Document, band: BandContainer): Paragraph[] => {\r\n  const list = paragraphsInBlocks(doc.section[band] ?? [], true);\r\n  if (_paraScanStats.enabled) {\r\n    _paraScanStats.bandCalls++;\r\n    _paraScanStats.bandSlots += list.length;\r\n  }\r\n  return list;\r\n};\r\n\r\n/** Body paragraphs in document order, INCLUDING table-cell paragraphs (one\r\n *  level deep). Excludes margin bands and footnote notes \u2014 the body story only.\r\n *  Heading/TOC scans use this so headings inside table cells are found too. */\r\nexport const bodyParagraphs = (doc: Document): Paragraph[] => paragraphsInBlocks(doc.blocks, true);\r\n\r\n/** Per-document memoized index of the navigable-paragraph space. The model is\r\n *  immutable \u2014 every edit returns a NEW Document object (path-clone) \u2014 so a\r\n *  WeakMap keyed on document identity auto-invalidates: a fresh doc simply misses\r\n *  the cache and the old entry is GC'd. Built once per doc, then `paragraphsOf`\r\n *  is a cached-array return and `blockById`/`blockIndexOf` are O(1) Map lookups,\r\n *  instead of re-walking the whole block tree (body + table cells + 6 bands +\r\n *  footnotes/endnotes) on every call. Mirrors layout/geometry.ts's TreeIndex. */\r\ninterface DocParaIndex {\r\n  list: Paragraph[];\r\n  /** id \u2192 its index in `list` (FIRST occurrence, matching the old `.find`/\r\n   *  `.findIndex` semantics for the rare duplicate id). */\r\n  byId: Map<string, number>;\r\n}\r\nconst paraIndexCache = new WeakMap<Document, DocParaIndex>();\r\n\r\nconst buildParaIndex = (doc: Document): DocParaIndex => {\r\n  const list = [\r\n    ...paragraphsInBlocks(doc.blocks, true),\r\n    ...BAND_CONTAINERS.flatMap((band) => bandParagraphs(doc, band)),\r\n    ...Object.values(doc.footnotes ?? {}).flat(),\r\n    ...Object.values(doc.endnotes ?? {}).flat(),\r\n  ];\r\n  const byId = new Map<string, number>();\r\n  for (let i = 0; i < list.length; i++) {\r\n    const id = list[i]!.id;\r\n    if (!byId.has(id)) byId.set(id, i); // keep first \u2014 matches old .find/.findIndex\r\n  }\r\n  if (_paraScanStats.enabled) {\r\n    _paraScanStats.fullCalls++;\r\n    _paraScanStats.fullSlots += list.length;\r\n  }\r\n  return { list, byId };\r\n};\r\n\r\nconst paraIndex = (doc: Document): DocParaIndex => {\r\n  let idx = paraIndexCache.get(doc);\r\n  if (!idx) {\r\n    idx = buildParaIndex(doc);\r\n    paraIndexCache.set(doc, idx);\r\n  }\r\n  return idx;\r\n};\r\n\r\n/** All editable paragraphs in document order: body (including table cells),\r\n *  then every band story (header/footer + first/even variants). This is the\r\n *  index space commands use. Cached per document identity (see DocParaIndex). */\r\nexport const paragraphsOf = (doc: Document): Paragraph[] => paraIndex(doc).list;\r\n\r\nexport const blockById = (doc: Document, blockId: string): Paragraph | undefined => {\r\n  const idx = paraIndex(doc);\r\n  const i = idx.byId.get(blockId);\r\n  return i === undefined ? undefined : idx.list[i];\r\n};\r\n\r\nexport const blockIndexOf = (doc: Document, blockId: string): number => {\r\n  const i = paraIndex(doc).byId.get(blockId);\r\n  return i === undefined ? -1 : i;\r\n};\r\n\r\n/** The set of every band (header/footer + variants) paragraph id, memoized per\r\n *  document identity. Lets a body-vs-band membership test be an O(1) Set lookup\r\n *  instead of re-walking all six band stories per query \u2014 the selection\r\n *  controller's caret navigation filters the body paragraphs against this on\r\n *  every arrow key. Same WeakMap-on-identity invalidation as the para index. */\r\nconst bandIdCache = new WeakMap<Document, ReadonlySet<string>>();\r\nexport const bandParagraphIds = (doc: Document): ReadonlySet<string> => {\r\n  let s = bandIdCache.get(doc);\r\n  if (!s) {\r\n    const built = new Set<string>();\r\n    for (const band of BAND_CONTAINERS) for (const p of bandParagraphs(doc, band)) built.add(p.id);\r\n    s = built;\r\n    bandIdCache.set(doc, s);\r\n  }\r\n  return s;\r\n};\r\n\r\n/** Body navigation order: the paragraphs the caret can reach while editing the\r\n *  body \u2014 `paragraphsOf` minus band paragraphs (they belong to their own header/\r\n *  footer story) and hidden (w:vanish) paragraphs (never laid out, so the caret\r\n *  skips them). Memoized per document identity: the selection controller derives\r\n *  this on every caret move, and the filter (a full pass plus a per-paragraph\r\n *  hidden test) is otherwise re-run several times per keystroke. Same\r\n *  WeakMap-on-identity invalidation as `paragraphsOf`. Treat the result as\r\n *  IMMUTABLE (callers read-only; see paragraphsOf). */\r\nconst navCache = new WeakMap<Document, Paragraph[]>();\r\nexport const navigableParagraphs = (doc: Document): Paragraph[] => {\r\n  let list = navCache.get(doc);\r\n  if (!list) {\r\n    const bandIds = bandParagraphIds(doc);\r\n    list = paragraphsOf(doc).filter((p) => !bandIds.has(p.id) && !isHiddenParagraph(p));\r\n    navCache.set(doc, list);\r\n  }\r\n  return list;\r\n};\r\n\r\n/** Story (header/footer editing) navigation order for ONE band container:\r\n *  `bandParagraphs(doc, band)` minus hidden (w:vanish) paragraphs the caret skips.\r\n *  The body counterpart is `navigableParagraphs`; this is the per-band analogue the\r\n *  selection controller derives on every caret move while editing a margin band.\r\n *  Memoized per (document identity, band) \u2014 a nested `Map<BandContainer, \u2026>` per\r\n *  doc, with the same WeakMap-on-identity invalidation. Treat the result as\r\n *  IMMUTABLE (callers read-only). */\r\nconst navBandCache = new WeakMap<Document, Map<BandContainer, Paragraph[]>>();\r\nexport const navigableBandParagraphs = (doc: Document, band: BandContainer): Paragraph[] => {\r\n  let perDoc = navBandCache.get(doc);\r\n  if (!perDoc) {\r\n    perDoc = new Map();\r\n    navBandCache.set(doc, perDoc);\r\n  }\r\n  let list = perDoc.get(band);\r\n  if (!list) {\r\n    list = bandParagraphs(doc, band).filter((p) => !isHiddenParagraph(p));\r\n    perDoc.set(band, list);\r\n  }\r\n  return list;\r\n};\r\n\r\n/** Every block id present anywhere in the doc \u2014 top-level blocks (paragraph,\r\n *  image, table) in body + bands, table ids, and paragraph/image ids nested in\r\n *  table cells. Used by the review layer's structural-suggestion GC, which keys\r\n *  on whole-block identity rather than a text offset range. */\r\nconst collectBlockIds = (blocks: Block[], into: Set<string>): void => {\r\n  for (const b of blocks) {\r\n    into.add(b.id);\r\n    if (b.kind === \"table\") {\r\n      for (const row of b.rows) for (const cell of row.cells) collectBlockIds(cell.blocks, into);\r\n    }\r\n  }\r\n};\r\n\r\n/** Does a block with this id exist anywhere in the document (any kind, any\r\n *  container, including table cells)? */\r\nexport const blockExists = (doc: Document, blockId: string): boolean => {\r\n  const ids = new Set<string>();\r\n  collectBlockIds(doc.blocks, ids);\r\n  for (const band of BAND_CONTAINERS) collectBlockIds(doc.section[band] ?? [], ids);\r\n  for (const paras of Object.values(doc.footnotes ?? {})) for (const p of paras) ids.add(p.id);\r\n  for (const paras of Object.values(doc.endnotes ?? {})) for (const p of paras) ids.add(p.id);\r\n  return ids.has(blockId);\r\n};\r\n\r\n// ---------------------------------------------------------------------------\r\n// Paragraph locator \u2014 content ops work on any paragraph, wherever it lives.\r\n\r\nexport type ParaLocation =\r\n  | { kind: \"top\"; bi: number }\r\n  | { kind: \"cell\"; where: \"body\" | BandContainer; bi: number; ri: number; ci: number; pi: number }\r\n  | { kind: \"band\"; band: BandContainer; bi: number }\r\n  | { kind: \"footnote\"; noteId: string; pi: number }\r\n  | { kind: \"endnote\"; noteId: string; pi: number };\r\n\r\n/** Top-level block list of a container (\"body\" or a band story). */\r\nexport const containerListOf = (doc: Document, where: \"body\" | BandContainer): Block[] =>\r\n  where === \"body\" ? doc.blocks : (doc.section[where] ?? []);\r\n\r\nfunction locateInBlocks(\r\n  blocks: Block[],\r\n  where: \"body\" | BandContainer,\r\n  blockId: string,\r\n): ParaLocation | null {\r\n  for (let bi = 0; bi < blocks.length; bi++) {\r\n    const b = blocks[bi]!;\r\n    if (b.kind === \"paragraph\") {\r\n      if (b.id === blockId) {\r\n        return where === \"body\" ? { kind: \"top\", bi } : { kind: \"band\", band: where, bi };\r\n      }\r\n    } else if (b.kind === \"table\") {\r\n      for (let ri = 0; ri < b.rows.length; ri++) {\r\n        const row = b.rows[ri]!;\r\n        for (let ci = 0; ci < row.cells.length; ci++) {\r\n          const cell = row.cells[ci]!;\r\n          for (let pi = 0; pi < cell.blocks.length; pi++) {\r\n            const cb = cell.blocks[pi]!;\r\n            // One level deep: paragraphs of nested tables stay read-only.\r\n            if (cb.kind === \"paragraph\" && cb.id === blockId) {\r\n              return { kind: \"cell\", where, bi, ri, ci, pi };\r\n            }\r\n          }\r\n        }\r\n      }\r\n    }\r\n  }\r\n  return null;\r\n}\r\n\r\nexport function locateParagraph(doc: Document, blockId: string): ParaLocation | null {\r\n  const body = locateInBlocks(doc.blocks, \"body\", blockId);\r\n  if (body) return body;\r\n  for (const band of BAND_CONTAINERS) {\r\n    const hit = locateInBlocks(doc.section[band] ?? [], band, blockId);\r\n    if (hit) return hit;\r\n  }\r\n  for (const [noteId, paras] of Object.entries(doc.footnotes ?? {})) {\r\n    const pi = paras.findIndex((p) => p.id === blockId);\r\n    if (pi >= 0) return { kind: \"footnote\", noteId, pi };\r\n  }\r\n  for (const [noteId, paras] of Object.entries(doc.endnotes ?? {})) {\r\n    const pi = paras.findIndex((p) => p.id === blockId);\r\n    if (pi >= 0) return { kind: \"endnote\", noteId, pi };\r\n  }\r\n  return null;\r\n}\r\n\r\nexport function paragraphAt(doc: Document, loc: ParaLocation): Paragraph {\r\n  if (loc.kind === \"top\") return doc.blocks[loc.bi] as Paragraph;\r\n  if (loc.kind === \"band\") return doc.section[loc.band]![loc.bi] as Paragraph;\r\n  if (loc.kind === \"footnote\") return doc.footnotes![loc.noteId]![loc.pi]!;\r\n  if (loc.kind === \"endnote\") return doc.endnotes![loc.noteId]![loc.pi]!;\r\n  const table = containerListOf(doc, loc.where)[loc.bi] as Extract<Block, { kind: \"table\" }>;\r\n  return table.rows[loc.ri]!.cells[loc.ci]!.blocks[loc.pi] as Paragraph;\r\n}\r\n\r\n/** Immutable path-clone replace; bumps the containing table's revision too. */\r\nexport function replaceParagraphAt(doc: Document, loc: ParaLocation, p: Paragraph): Document {\r\n  if (loc.kind === \"footnote\") {\r\n    const paras = doc.footnotes![loc.noteId]!.slice();\r\n    paras[loc.pi] = p;\r\n    return { ...doc, footnotes: { ...doc.footnotes, [loc.noteId]: paras } };\r\n  }\r\n  if (loc.kind === \"endnote\") {\r\n    const paras = doc.endnotes![loc.noteId]!.slice();\r\n    paras[loc.pi] = p;\r\n    return { ...doc, endnotes: { ...doc.endnotes, [loc.noteId]: paras } };\r\n  }\r\n  if (loc.kind === \"band\") {\r\n    const blocks = (doc.section[loc.band] ?? []).slice();\r\n    blocks[loc.bi] = p;\r\n    return { ...doc, section: { ...doc.section, [loc.band]: blocks } };\r\n  }\r\n  if (loc.kind === \"top\") {\r\n    const blocks = doc.blocks.slice();\r\n    blocks[loc.bi] = p;\r\n    return { ...doc, blocks };\r\n  }\r\n  const blocks = containerListOf(doc, loc.where).slice();\r\n  const table = blocks[loc.bi] as Extract<Block, { kind: \"table\" }>;\r\n  const rows = table.rows.slice();\r\n  const row = { cells: rows[loc.ri]!.cells.slice() };\r\n  const cell = { ...row.cells[loc.ci]!, blocks: row.cells[loc.ci]!.blocks.slice() };\r\n  cell.blocks[loc.pi] = p;\r\n  row.cells[loc.ci] = cell;\r\n  rows[loc.ri] = row;\r\n  blocks[loc.bi] = { ...table, rows, revision: table.revision + 1 };\r\n  if (loc.where === \"body\") return { ...doc, blocks };\r\n  return { ...doc, section: { ...doc.section, [loc.where]: blocks } };\r\n}\r\n\r\nexport const isInCell = (doc: Document, blockId: string): boolean =>\r\n  locateParagraph(doc, blockId)?.kind === \"cell\";\r\n\r\nexport const textOfRuns = (runs: Run[]): string => runs.map((r) => r.text).join(\"\");\r\n\r\nexport const textOfBlock = (doc: Document, blockId: string): string => {\r\n  const b = blockById(doc, blockId);\r\n  return b ? textOfRuns(b.runs) : \"\";\r\n};\r\n\r\nexport function prevGrapheme(text: string, offset: number): number {\r\n  let prev = 0;\r\n  for (const s of graphemes.segment(text)) {\r\n    if (s.index >= offset) break;\r\n    prev = s.index;\r\n  }\r\n  return prev;\r\n}\r\n\r\nexport function nextGrapheme(text: string, offset: number): number {\r\n  for (const s of graphemes.segment(text)) {\r\n    const end = s.index + s.segment.length;\r\n    if (end > offset) return end;\r\n  }\r\n  return text.length;\r\n}\r\n\r\nexport function prevWordStart(text: string, offset: number): number {\r\n  let prev = 0;\r\n  for (const s of words.segment(text)) {\r\n    if (s.index >= offset) break;\r\n    if (s.isWordLike) prev = s.index;\r\n  }\r\n  return prev;\r\n}\r\n\r\nexport function nextWordEnd(text: string, offset: number): number {\r\n  for (const s of words.segment(text)) {\r\n    const end = s.index + s.segment.length;\r\n    if (s.isWordLike && end > offset) return end;\r\n  }\r\n  return text.length;\r\n}\r\n\r\n/** Style of the character before `offset` (Word: typing inherits what precedes\r\n *  the caret), falling back to the first run's style. */\r\nexport function styleAtRuns(runs: Run[], offset: number): CharStyle | undefined {\r\n  let cum = 0;\r\n  for (const r of runs) {\r\n    const end = cum + r.text.length;\r\n    // offset-1 falls inside this run -> its style precedes the caret\r\n    if (offset > cum && offset <= end && r.text.length > 0) return r.style;\r\n    cum = end;\r\n  }\r\n  return runs[0]?.style;\r\n}\r\n\r\n/** Style of the character AT `index` (the run covering it), or undefined when out\r\n *  of range. Distinct from styleAtRuns (which returns the char BEFORE a caret\r\n *  offset): use this to inspect a specific character, e.g. an inline-equation\r\n *  sentinel located by its run index. */\r\nexport function styleOfCharAt(runs: Run[], index: number): CharStyle | undefined {\r\n  if (index < 0) return undefined;\r\n  let cum = 0;\r\n  for (const r of runs) {\r\n    if (index >= cum && index < cum + r.text.length) return r.style;\r\n    cum += r.text.length;\r\n  }\r\n  return undefined;\r\n}\r\n", "// List definitions \u2014 a direct mirror of OOXML numbering.xml abstractNum levels,\n// so the docx importer can feed Document.lists losslessly (id space = numId).\n// Markers are PAINT-ONLY: they live in the hanging indent and never affect line\n// breaking (matching Word's overlap behavior for very long markers).\n\nimport type { CharStyle } from \"./document\";\n\nexport type ListNumberFormat =\n  | \"bullet\"\n  | \"decimal\"\n  | \"lowerLetter\"\n  | \"upperLetter\"\n  | \"lowerRoman\"\n  | \"upperRoman\";\n\nexport interface ListLevel {\n  format: ListNumberFormat;\n  /** Marker pattern; %N is the counter of level N-1, formatted per THAT level\n   *  (OOXML \u00A717.9.11 semantics). E.g. \"%1.\" or \"%1.%2.%3\". Ignored for bullets. */\n  text: string;\n  bulletChar?: string;\n  /** Text indent for paragraphs at this level (added to ParaStyle.indentLeftPx). */\n  indentLeftPx: number;\n  /** Marker hangs this far left of the text origin. */\n  hangingPx: number;\n  start: number;\n  markerStyle?: Partial<CharStyle>;\n}\n\nexport interface ListDefinition {\n  id: string;\n  levels: ListLevel[]; // up to 9 (levels 0..8)\n}\n\n// ---------------------------------------------------------------------------\n// Number formatting\n\nconst ROMAN: [number, string][] = [\n  [1000, \"m\"], [900, \"cm\"], [500, \"d\"], [400, \"cd\"], [100, \"c\"], [90, \"xc\"],\n  [50, \"l\"], [40, \"xl\"], [10, \"x\"], [9, \"ix\"], [5, \"v\"], [4, \"iv\"], [1, \"i\"],\n];\n\nfunction toRoman(n: number): string {\n  let out = \"\";\n  let v = Math.max(1, n);\n  for (const [value, sym] of ROMAN) {\n    while (v >= value) {\n      out += sym;\n      v -= value;\n    }\n  }\n  return out;\n}\n\nfunction toLetter(n: number): string {\n  // 1->a .. 26->z, 27->aa (Word repeats: 27 is actually \"aa\")\n  let out = \"\";\n  let v = Math.max(1, n);\n  while (v > 0) {\n    v -= 1;\n    out = String.fromCharCode(97 + (v % 26)) + out;\n    v = Math.floor(v / 26);\n  }\n  return out;\n}\n\nexport function formatListNumber(n: number, format: ListNumberFormat): string {\n  switch (format) {\n    case \"decimal\": return String(n);\n    case \"lowerLetter\": return toLetter(n);\n    case \"upperLetter\": return toLetter(n).toUpperCase();\n    case \"lowerRoman\": return toRoman(n);\n    case \"upperRoman\": return toRoman(n).toUpperCase();\n    case \"bullet\": return \"\";\n  }\n}\n\n/** Render a level's marker from the counter stack (counters[k] = level k's value). */\nexport function markerText(def: ListDefinition, level: number, counters: number[]): string {\n  const lvl = def.levels[Math.min(level, def.levels.length - 1)];\n  if (!lvl) return \"\";\n  if (lvl.format === \"bullet\") return lvl.bulletChar ?? DEFAULT_BULLET;\n  return lvl.text.replace(/%(\\d)/g, (_, d: string) => {\n    const k = Number(d) - 1;\n    const refLevel = def.levels[Math.min(k, def.levels.length - 1)];\n    const value = counters[k] ?? refLevel?.start ?? 1;\n    return formatListNumber(value, refLevel?.format ?? \"decimal\");\n  });\n}\n\n// ---------------------------------------------------------------------------\n// Default definitions (what the toolbar buttons create)\n\nexport const DEFAULT_BULLET_LIST_ID = \"bullets\";\nexport const DEFAULT_NUMBER_LIST_ID = \"numbers\";\nexport const DEFAULT_MULTILEVEL_LIST_ID = \"multilevel\";\n\n/** OOXML abstractNum holds up to 9 levels (0..8). */\nconst LIST_LEVELS = 9;\n/** Per-level text indent + step (px): level i sits at LIST_INDENT_STEP_PX*(i+1). */\nconst LIST_INDENT_STEP_PX = 24;\n/** How far the marker hangs left of the text origin, per list kind. */\nconst BULLET_HANGING_PX = 18;\nconst NUMBER_HANGING_PX = 22;\n\nconst DEFAULT_BULLET = \"\u2022\";\nconst BULLETS = [DEFAULT_BULLET, \"\u25E6\", \"\u25AA\"];\nconst NUMBER_FORMATS: ListNumberFormat[] = [\"decimal\", \"lowerLetter\", \"lowerRoman\"];\n\nconst levelIndentPx = (i: number): number => LIST_INDENT_STEP_PX * (i + 1);\n\nexport function defaultListDefinition(kind: \"bullet\" | \"decimal\"): ListDefinition {\n  const levels: ListLevel[] = [];\n  for (let i = 0; i < LIST_LEVELS; i++) {\n    if (kind === \"bullet\") {\n      levels.push({\n        format: \"bullet\",\n        text: \"\",\n        bulletChar: BULLETS[i % BULLETS.length]!,\n        indentLeftPx: levelIndentPx(i),\n        hangingPx: BULLET_HANGING_PX,\n        start: 1,\n      });\n    } else {\n      levels.push({\n        format: NUMBER_FORMATS[i % NUMBER_FORMATS.length]!,\n        text: `%${i + 1}.`,\n        indentLeftPx: levelIndentPx(i),\n        hangingPx: NUMBER_HANGING_PX,\n        start: 1,\n      });\n    }\n  }\n  return { id: kind === \"bullet\" ? DEFAULT_BULLET_LIST_ID : DEFAULT_NUMBER_LIST_ID, levels };\n}\n\n/** A single-glyph bullet list (every level uses `char`) \u2014 what the bullet\n *  style picker applies. */\nexport function bulletListDefinition(id: string, char: string): ListDefinition {\n  const levels: ListLevel[] = [];\n  for (let i = 0; i < LIST_LEVELS; i++) {\n    levels.push({ format: \"bullet\", text: \"\", bulletChar: char, indentLeftPx: levelIndentPx(i), hangingPx: BULLET_HANGING_PX, start: 1 });\n  }\n  return { id, levels };\n}\n\n/** A single-format numbered list (every level uses `format`), with `suffix`\n *  after each counter (\".\" or \")\") \u2014 what the number style picker applies. */\nexport function numberListDefinition(id: string, format: ListNumberFormat, suffix: string): ListDefinition {\n  const levels: ListLevel[] = [];\n  for (let i = 0; i < LIST_LEVELS; i++) {\n    levels.push({ format, text: `%${i + 1}${suffix}`, indentLeftPx: levelIndentPx(i), hangingPx: NUMBER_HANGING_PX, start: 1 });\n  }\n  return { id, levels };\n}\n\n/** Legal-style multilevel list: every level is decimal and its marker compounds\n *  all ancestors \u2014 level 0 \"1.\", level 1 \"1.1.\", level 2 \"1.1.1.\", \u2026 (Word's\n *  default Multilevel List). Tab/Shift+Tab walk the levels. */\nexport function multilevelListDefinition(): ListDefinition {\n  const levels: ListLevel[] = [];\n  for (let i = 0; i < LIST_LEVELS; i++) {\n    const text = Array.from({ length: i + 1 }, (_, k) => `%${k + 1}`).join(\".\") + \".\";\n    levels.push({\n      format: \"decimal\",\n      text, // \"%1.\", \"%1.%2.\", \"%1.%2.%3.\", \u2026\n      indentLeftPx: levelIndentPx(i),\n      hangingPx: LIST_INDENT_STEP_PX + i * 8, // compound markers widen with depth\n      start: 1,\n    });\n  }\n  return { id: DEFAULT_MULTILEVEL_LIST_ID, levels };\n}\n", "// Content-control (OOXML w:sdt) path helpers.\r\n//\r\n// SDT membership is an ORDERED ANCESTRY PATH (outer\u2192inner) so controls can nest:\r\n//   - inline controls put their ids on `CharStyle.sdtPath` (within a paragraph);\r\n//   - block-level controls put their ids on `Block.sdtPath` (whole paragraphs/\r\n//     tables, incl. run-less blocks).\r\n// A run's full enclosing chain is `block.sdtPath ++ run.style.sdtPath`. The props\r\n// for every id live in `Document.sdts`. Paths are treated as immutable (always\r\n// replaced, never mutated in place) and are never stored as `[]` \u2014 use undefined.\r\n\r\nimport type { Block, CharStyle } from \"./document\";\r\n\r\n/** The innermost (most specific) inline control id at a run, or undefined. */\r\nexport function innermostSdtId(style: CharStyle): string | undefined {\r\n  const p = style.sdtPath;\r\n  return p && p.length > 0 ? p[p.length - 1] : undefined;\r\n}\r\n\r\n/** The innermost block-level control id wrapping a block, or undefined. */\r\nexport function blockInnermostSdtId(block: Block): string | undefined {\r\n  const p = block.sdtPath;\r\n  return p && p.length > 0 ? p[p.length - 1] : undefined;\r\n}\r\n\r\n/** A run's full enclosing control chain, outer\u2192inner: block ancestry (prefix)\r\n *  followed by inline ancestry (suffix). Empty array if none. */\r\nexport function fullSdtChain(block: Block | undefined, style: CharStyle): string[] {\r\n  const bp = block?.sdtPath ?? [];\r\n  const ip = style.sdtPath ?? [];\r\n  return bp.length === 0 ? ip.slice() : bp.concat(ip);\r\n}\r\n\r\n/** Path equality treating `undefined` and `[]` as equal (the empty path). */\r\nexport function sdtPathEq(a: string[] | undefined, b: string[] | undefined): boolean {\r\n  const al = a?.length ?? 0;\r\n  const bl = b?.length ?? 0;\r\n  if (al !== bl) return false;\r\n  for (let i = 0; i < al; i++) if (a![i] !== b![i]) return false;\r\n  return true;\r\n}\r\n\r\n/** Length of the shared outer prefix of two paths (for LCP grouping on export). */\r\nexport function commonPrefixLen(a: string[], b: string[]): number {\r\n  const n = Math.min(a.length, b.length);\r\n  let i = 0;\r\n  while (i < n && a[i] === b[i]) i++;\r\n  return i;\r\n}\r\n\r\n/** Whether a run's inline path contains `id` (membership at any nesting level). */\r\nexport function inSdt(style: CharStyle, id: string): boolean {\r\n  return style.sdtPath?.includes(id) ?? false;\r\n}\r\n\r\n/** Whether a block's path contains `id`. */\r\nexport function blockInSdt(block: Block, id: string): boolean {\r\n  return block.sdtPath?.includes(id) ?? false;\r\n}\r\n\r\n/** Normalize a candidate path: undefined for empty, else a fresh array. */\r\nexport function normSdtPath(path: string[] | undefined): string[] | undefined {\r\n  return path && path.length > 0 ? path.slice() : undefined;\r\n}\r\n\r\n/** Append a control id to a path (new array), for wrapping inside existing ones. */\r\nexport function pushSdt(path: string[] | undefined, id: string): string[] {\r\n  return path && path.length > 0 ? [...path, id] : [id];\r\n}\r\n\r\n/** Remove ONE control id from a path (new array), preserving ancestry; returns\r\n *  undefined when the path becomes empty. Used by \"remove control\". */\r\nexport function removeSdt(path: string[] | undefined, id: string): string[] | undefined {\r\n  if (!path) return undefined;\r\n  const next = path.filter((x) => x !== id);\r\n  return next.length > 0 ? next : undefined;\r\n}\r\n\r\n/** The path prefix up to and INCLUDING `id` \u2014 the ancestry that newly inserted\r\n *  content replacing control `id`'s contents must carry. Returns undefined if\r\n *  `id` is not on the path. */\r\nexport function ancestryThrough(path: string[] | undefined, id: string): string[] | undefined {\r\n  if (!path) return undefined;\r\n  const idx = path.indexOf(id);\r\n  return idx < 0 ? undefined : path.slice(0, idx + 1);\r\n}\r\n", "// The editor's default (\"Normal\") run + paragraph formatting, as CONCRETE\n// values. The model keeps runs/paragraphs concrete (every CharStyle/ParaStyle\n// field present), so every \"no style yet\" path \u2014 text insertion fallback,\n// paste, the sample document, the builder baselines, comment runs \u2014 needs a\n// full default to spread from. These are that single source of truth; keep them\n// in sync with the \"Normal\" style declared in makeDefaultStylesheet()\n// (stylesheet.ts), which is the same look expressed as a style delta.\n//\n// Embedders can OVERRIDE the library's built-in defaults (see EditorTypography\n// + the WordCanvas `overrideDefaultStyles` option). This only affects NEW/blank\n// documents and the fallback stylesheet \u2014 a loaded .docx keeps its own\n// w:docDefaults / Normal style (the importer bakes those in at import time).\n\nimport type { CharStyle, ParaStyle } from \"./document\";\n\n/** Per-instance typography override for the library's built-in defaults. Every\n *  field is optional; omit to keep the built-in value. Drives both the concrete\n *  default run/paragraph styles and the generated default stylesheet. */\nexport interface EditorTypography {\n  /** Body (Normal) font family, e.g. \"Times New Roman, serif\". */\n  fontFamily?: string;\n  /** Body font size in px (96 dpi). */\n  fontSizePx?: number;\n  /** Body text color (any CSS color string). */\n  color?: string;\n  /** Default paragraph line height (multiplier). */\n  lineHeight?: number;\n  /** Heading font family (Title/Heading1/Heading2). Omit to keep the built-in. */\n  headingFontFamily?: string;\n}\n\n/** Built-in body run formatting \u2014 Georgia 16px on near-black (#202124). */\nexport function makeDefaultCharStyle(t: EditorTypography = {}): CharStyle {\n  return {\n    fontFamily: t.fontFamily ?? \"Georgia, serif\",\n    fontSizePx: t.fontSizePx ?? 16,\n    bold: false,\n    italic: false,\n    underline: false,\n    strikethrough: false,\n    color: t.color ?? \"#202124\",\n  };\n}\n\n/** Built-in paragraph formatting \u2014 left, 1.5 line height, 12px after. */\nexport function makeDefaultParaStyle(t: EditorTypography = {}): ParaStyle {\n  return {\n    align: \"left\",\n    lineHeight: t.lineHeight ?? 1.5,\n    spaceBeforePx: 0,\n    spaceAfterPx: 12,\n    indentFirstLinePx: 0,\n    indentLeftPx: 0,\n  };\n}\n\n/** Default body run formatting (built-in, no overrides). */\nexport const DEFAULT_CHAR_STYLE: CharStyle = makeDefaultCharStyle();\n\n/** Default paragraph formatting (built-in, no overrides). */\nexport const DEFAULT_PARA_STYLE: ParaStyle = makeDefaultParaStyle();\n", "// All mutation flows through operations. Applying an op returns the new document\r\n// (structurally shared), the op's exact INVERSE (undo is free), and a position\r\n// mapper so selections survive edits. This seam is also where OT/CRDT\r\n// collaboration would slot in later.\r\n\r\nimport type {\r\n  BandContainer,\r\n  Block,\r\n  BookmarkRange,\r\n  CharStyle,\r\n  Document,\r\n  EquationBlock,\r\n  FieldDef,\r\n  ImageBlock,\r\n  ParaStyle,\r\n  Paragraph,\r\n  Run,\r\n  RowProps,\r\n  SdtProps,\r\n  TableBlock,\r\n  TableCell,\r\n  TableRow,\r\n} from \"./document\";\r\nimport { BAND_CONTAINERS } from \"./document\";\r\nimport type { MathEquation } from \"./math\";\r\nimport { sdtPathEq } from \"./sdt\";\r\nimport { DEFAULT_CHAR_STYLE } from \"./defaults\";\r\nimport type { DocPosition } from \"./position\";\r\nimport {\r\n  locateParagraph,\r\n  paragraphAt,\r\n  replaceParagraphAt,\r\n  styleAtRuns,\r\n  textOfRuns,\r\n  type ParaLocation,\r\n} from \"./text\";\r\n\r\n/** setImageProps payload. `wrap` and `anchor` are mutually-exclusive states, so\r\n *  each accepts `null` as an explicit \"clear this field\" sentinel (plain\r\n *  `undefined` means \"leave unchanged\", which exactOptionalPropertyTypes also\r\n *  needs to keep these distinguishable). */\r\nexport interface ImagePropsPatch {\r\n  widthPx?: number;\r\n  heightPx?: number;\r\n  align?: ImageBlock[\"align\"];\r\n  wrap?: ImageBlock[\"wrap\"] | null;\r\n  anchor?: ImageBlock[\"anchor\"] | null;\r\n  /** Crop insets (a:srcRect 0..1 fractions). `null` clears the crop. */\r\n  crop?: ImageBlock[\"crop\"] | null;\r\n}\r\n\r\n/** setTableProps payload \u2014 table-LEVEL fields (w:tblPr): indent + the cascade\r\n *  defaults (borders/shading/cell margins). Each key follows the setImageProps\r\n *  convention: a value sets the field, `null` clears it, and an absent key leaves\r\n *  it unchanged (exactOptionalPropertyTypes keeps the two distinguishable). */\r\nexport interface TablePropsPatch {\r\n  indentPx?: number | null;\r\n  defaultBorders?: import(\"./document\").TableBorders | null;\r\n  defaultShading?: string | null;\r\n  defaultCellMargin?: import(\"./document\").CellMargin | null;\r\n}\r\n\r\n/** Clamp crop insets to the documented invariant \u2014 each in [0,1) with a non-empty\r\n *  visible window \u2014 so a malformed local/remote patch can't persist impossible\r\n *  values (negative, NaN, or a fully-collapsed window) in the shared model. */\r\nfunction normalizeCrop(c: NonNullable<ImageBlock[\"crop\"]>): NonNullable<ImageBlock[\"crop\"]> {\r\n  const clamp = (v: number): number => (Number.isFinite(v) ? Math.min(0.999, Math.max(0, v)) : 0);\r\n  let { left, top, right, bottom } = { left: clamp(c.left), top: clamp(c.top), right: clamp(c.right), bottom: clamp(c.bottom) };\r\n  if (left + right >= 1) {\r\n    const k = 0.999 / (left + right);\r\n    left *= k;\r\n    right *= k;\r\n  }\r\n  if (top + bottom >= 1) {\r\n    const k = 0.999 / (top + bottom);\r\n    top *= k;\r\n    bottom *= k;\r\n  }\r\n  return { left, top, right, bottom };\r\n}\r\n\r\nexport type Op =\r\n  | { type: \"insertText\"; at: DocPosition; text: string; style?: CharStyle }\r\n  | { type: \"insertRuns\"; at: DocPosition; runs: Run[] }\r\n  | { type: \"deleteRange\"; blockId: string; start: number; end: number }\r\n  | { type: \"setRuns\"; blockId: string; runs: Run[] }\r\n  | { type: \"setParaStyle\"; blockId: string; patch: Partial<ParaStyle> }\r\n  | { type: \"splitParagraph\"; at: DocPosition; newBlockId: string; newStyle?: ParaStyle; newSdtPath?: string[] }\r\n  | { type: \"mergeParagraphs\"; firstBlockId: string }\r\n  | { type: \"insertBlock\"; index: number; block: Block; where?: Container }\r\n  | { type: \"removeBlock\"; blockId: string }\r\n  | { type: \"setImageProps\"; blockId: string; patch: ImagePropsPatch }\r\n  | { type: \"setEquation\"; blockId: string; equation: MathEquation }\r\n  | { type: \"setEquationAlign\"; blockId: string; align: \"left\" | \"center\" | \"right\" }\r\n  | { type: \"setTableRow\"; tableId: string; rowIndex: number; row: TableRow }\r\n  | { type: \"setTableStructure\"; tableId: string; rows: TableRow[]; colFractions?: number[] }\r\n  | { type: \"setTableStyleRef\"; tableId: string; styleId: string | null; condOverrides?: import(\"./document\").TableCondOverrides | null }\r\n  | { type: \"setTableColFractions\"; blockId: string; fractions: number[] }\r\n  | { type: \"setTableWidthMode\"; blockId: string; mode: TableBlock[\"widthMode\"] }\r\n  | { type: \"setTablePreferredWidth\"; blockId: string; width: TableBlock[\"preferredWidth\"] | null }\r\n  | { type: \"setTableAlign\"; blockId: string; align: TableBlock[\"align\"] | null }\r\n  | { type: \"setTableProps\"; blockId: string; patch: TablePropsPatch }\r\n  | { type: \"insertTableRow\"; tableId: string; rowIndex: number; row: TableRow }\r\n  | { type: \"removeTableRow\"; tableId: string; rowIndex: number }\r\n  | { type: \"setRowHeight\"; tableId: string; rowIndex: number; height: NonNullable<RowProps[\"height\"]> | null }\r\n  | { type: \"insertTableColumn\"; tableId: string; colIndex: number; cells: TableCell[]; fractions?: number[] }\r\n  | { type: \"removeTableColumn\"; tableId: string; colIndex: number }\r\n  | { type: \"setStylesheet\"; stylesheet: import(\"./stylesheet\").Stylesheet }\r\n  | { type: \"setTableStyleSheet\"; tableStyles: Record<string, import(\"./tableStyles\").TableStyle> }\r\n  | { type: \"setListDefinition\"; listId: string; def: import(\"./lists\").ListDefinition | null }\r\n  | { type: \"setSectionProps\"; geometry: SectionGeometry }\r\n  | { type: \"setSectionBand\"; band: BandContainer; blocks: Block[] | null }\r\n  | { type: \"setFootnote\"; noteId: string; paras: Paragraph[] | null }\r\n  | { type: \"setEndnote\"; noteId: string; paras: Paragraph[] | null }\r\n  | { type: \"setSdtProps\"; id: string; props: SdtProps | null }\r\n  | { type: \"setField\"; id: string; def: FieldDef | null }\r\n  | { type: \"setTocInstruction\"; instruction: string | null }\r\n  | { type: \"setBookmark\"; name: string; range: BookmarkRange | null };\r\n\r\n/** Page-setup fields of the final section (`doc.section`). Bands are NOT here \u2014\r\n *  they change through container ops; mid-document sections change through\r\n *  setParaStyle on their break paragraph's `sectionBreak.props`. */\r\nexport interface SectionGeometry {\r\n  pageWidthPx: number;\r\n  pageHeightPx: number;\r\n  marginPx: { top: number; right: number; bottom: number; left: number };\r\n  /** `null` = single column (the explicit \"off\" \u2014 SectionPatch distinguishes it\r\n   *  from \"inherit\"). `sep`/`cols` carry the separator line and per-column\r\n   *  widths respectively. */\r\n  columns: { count: number; gapPx: number; sep?: boolean; cols?: import(\"./document\").ColumnEntry[] } | null;\r\n  /** `null` = continue numbering from the previous section. */\r\n  pageNumberStart: number | null;\r\n  /** `null` = inherit (center band in margin). px from page top to header top. */\r\n  headerDistancePx: number | null;\r\n  /** `null` = inherit (center band in margin). px from page bottom to footer bottom. */\r\n  footerDistancePx: number | null;\r\n  /** `null` = no page fill. \"#rrggbb\". */\r\n  pageColorHex: string | null;\r\n  /** `null` = no page border. */\r\n  pageBorders: import(\"./document\").PageBorders | null;\r\n  /** OOXML w:sectPr/w:type for the section START. `null` = the default (\"nextPage\");\r\n   *  \"evenPage\"/\"oddPage\" force the section's first page onto an even/odd page. */\r\n  breakType: import(\"./document\").SectionBreakType | null;\r\n  /** w:sectPr/w:lnNumType \u2014 line numbering in the margin. `null` = off. */\r\n  lineNumbering: import(\"./document\").LineNumbering | null;\r\n}\r\n\r\n/** Top-level block containers: the body, or one of the six margin-band stories\r\n *  (default header/footer + first/even variants). */\r\nexport type Container = \"body\" | BandContainer;\r\n\r\nexport interface ApplyResult {\r\n  doc: Document;\r\n  inverse: Op;\r\n  /** Remaps any stored position across this edit (selection, bookmarks). */\r\n  mapPosition(pos: DocPosition): DocPosition;\r\n  dirtyBlockIds: string[];\r\n}\r\n\r\n// ---------------------------------------------------------------------------\r\n// Run-list surgery (pure helpers)\r\n\r\n/** Compare two w:sym markers by value (font + code point). */\r\nfunction symbolEq(a: CharStyle[\"symbol\"], b: CharStyle[\"symbol\"]): boolean {\r\n  if (!a || !b) return !a === !b;\r\n  return a.font === b.font && a.char === b.char;\r\n}\r\n\r\nexport function styleEq(a: CharStyle, b: CharStyle): boolean {\r\n  return (\r\n    a.fontFamily === b.fontFamily &&\r\n    a.fontFamilyComplexScript === b.fontFamilyComplexScript &&\r\n    a.fontFamilyEastAsia === b.fontFamilyEastAsia &&\r\n    a.fontSizePx === b.fontSizePx &&\r\n    a.bold === b.bold &&\r\n    a.italic === b.italic &&\r\n    a.underline === b.underline &&\r\n    a.underlineStyle === b.underlineStyle &&\r\n    a.underlineColor === b.underlineColor &&\r\n    a.strikethrough === b.strikethrough &&\r\n    a.color === b.color &&\r\n    !!a.hidden === !!b.hidden && // hidden runs must never merge with visible ones\r\n    (a.letterSpacingPx ?? 0) === (b.letterSpacingPx ?? 0) &&\r\n    a.highlightColor === b.highlightColor &&\r\n    a.verticalAlign === b.verticalAlign &&\r\n    !!a.caps === !!b.caps && // case transforms change the rendered glyphs \u2014 never merge across\r\n    !!a.smallCaps === !!b.smallCaps &&\r\n    a.link === b.link &&\r\n    a.footnoteRef === b.footnoteRef && // adjacent refs must never merge into one run\r\n    sdtPathEq(a.sdtPath, b.sdtPath) && // content-control boundaries (incl. nesting) survive normalization\r\n    a.fieldId === b.fieldId && // inline-field boundaries survive normalization\r\n    a.equation === b.equation && // inline equations are atomic \u2014 never merge (reference identity)\r\n    // Minor run typography & effects (w:rPr extras) \u2014 compared so styled runs never\r\n    // merge with plain ones (and a struck-through pair keeps its boundary).\r\n    !!a.doubleStrikethrough === !!b.doubleStrikethrough &&\r\n    (a.positionPx ?? 0) === (b.positionPx ?? 0) &&\r\n    (a.kerningMinPx ?? 0) === (b.kerningMinPx ?? 0) &&\r\n    (a.widthScalePct ?? 100) === (b.widthScalePct ?? 100) &&\r\n    a.emphasisMark === b.emphasisMark &&\r\n    !!a.outline === !!b.outline &&\r\n    !!a.shadow === !!b.shadow &&\r\n    !!a.emboss === !!b.emboss &&\r\n    !!a.imprint === !!b.imprint &&\r\n    (a.fitTextPx ?? 0) === (b.fitTextPx ?? 0) &&\r\n    runBorderEq(a.runBorder, b.runBorder) &&\r\n    symbolEq(a.symbol, b.symbol) // symbol glyphs (w:sym) carry font+codepoint \u2014 never merge with text\r\n  );\r\n}\r\n\r\n/** Structural equality for a run border (w:bdr) \u2014 runs with differently-styled\r\n *  borders must not merge, but two imported runs with identical borders may. */\r\nfunction runBorderEq(a: CharStyle[\"runBorder\"], b: CharStyle[\"runBorder\"]): boolean {\r\n  if (a === b) return true;\r\n  if (!a || !b) return false;\r\n  return a.color === b.color && a.widthPx === b.widthPx && a.style === b.style;\r\n}\r\n\r\n/** Merge equal-styled neighbors, drop empties. An all-empty paragraph keeps ONE\r\n *  empty run so the paragraph mark still carries a style (Word behavior). */\r\nexport function normalizeRuns(runs: Run[], fallback: CharStyle): Run[] {\r\n  const nonEmpty = runs.filter((r) => r.text.length > 0);\r\n  if (nonEmpty.length === 0) return [{ text: \"\", style: runs[0]?.style ?? fallback }];\r\n  const out: Run[] = [{ ...nonEmpty[0]! }];\r\n  for (let i = 1; i < nonEmpty.length; i++) {\r\n    const r = nonEmpty[i]!;\r\n    const last = out[out.length - 1]!;\r\n    if (styleEq(last.style, r.style)) last.text += r.text;\r\n    else out.push({ ...r });\r\n  }\r\n  return out;\r\n}\r\n\r\n/** Split a run list at a UTF-16 offset. */\r\nexport function splitRunsAt(runs: Run[], offset: number): [Run[], Run[]] {\r\n  const head: Run[] = [];\r\n  const tail: Run[] = [];\r\n  let cum = 0;\r\n  for (const r of runs) {\r\n    const end = cum + r.text.length;\r\n    if (end <= offset) head.push(r);\r\n    else if (cum >= offset) tail.push(r);\r\n    else {\r\n      head.push({ text: r.text.slice(0, offset - cum), style: r.style });\r\n      tail.push({ text: r.text.slice(offset - cum), style: r.style });\r\n    }\r\n    cum = end;\r\n  }\r\n  return [head, tail];\r\n}\r\n\r\nexport function sliceRuns(runs: Run[], start: number, end: number): Run[] {\r\n  const [, fromStart] = splitRunsAt(runs, start);\r\n  const [middle] = splitRunsAt(fromStart, end - start);\r\n  return middle;\r\n}\r\n\r\nfunction fallbackStyle(runs: Run[], offset: number): CharStyle {\r\n  return styleAtRuns(runs, offset) ?? { ...DEFAULT_CHAR_STYLE };\r\n}\r\n\r\nexport function insertTextInRuns(runs: Run[], offset: number, text: string, style?: CharStyle): Run[] {\r\n  const st = style ?? fallbackStyle(runs, offset);\r\n  const [head, tail] = splitRunsAt(runs, offset);\r\n  return normalizeRuns([...head, { text, style: st }, ...tail], st);\r\n}\r\n\r\nexport function insertRunsInRuns(runs: Run[], offset: number, inserted: Run[]): Run[] {\r\n  const [head, tail] = splitRunsAt(runs, offset);\r\n  return normalizeRuns([...head, ...inserted, ...tail], fallbackStyle(runs, offset));\r\n}\r\n\r\nexport function deleteInRuns(runs: Run[], start: number, end: number): Run[] {\r\n  const [head, fromStart] = splitRunsAt(runs, start);\r\n  const [, tail] = splitRunsAt(fromStart, end - start);\r\n  return normalizeRuns([...head, ...tail], fallbackStyle(runs, start));\r\n}\r\n\r\nexport function applyStylePatchToRuns(\r\n  runs: Run[],\r\n  start: number,\r\n  end: number,\r\n  patch: Partial<CharStyle>,\r\n): Run[] {\r\n  const [head, fromStart] = splitRunsAt(runs, start);\r\n  const [middle, tail] = splitRunsAt(fromStart, end - start);\r\n  const styled = middle.map((r) => ({ text: r.text, style: { ...r.style, ...patch } }));\r\n  return normalizeRuns([...head, ...styled, ...tail], fallbackStyle(runs, start));\r\n}\r\n\r\n/** Rewrite the TEXT of runs in [start,end) through `fn`, preserving each run's\r\n *  style. `fn` receives the whole covered string (so it can do context-aware\r\n *  transforms like sentence case) and must return a string of the SAME length \u2014\r\n *  if the length changes the slice is left untouched (run offsets must stay\r\n *  stable). Used by change-case; transforms here are 1:1 per character. */\r\nexport function mapTextInRuns(\r\n  runs: Run[],\r\n  start: number,\r\n  end: number,\r\n  fn: (covered: string) => string,\r\n): Run[] {\r\n  const [head, fromStart] = splitRunsAt(runs, start);\r\n  const [middle, tail] = splitRunsAt(fromStart, end - start);\r\n  const original = middle.map((r) => r.text).join(\"\");\r\n  const next = fn(original);\r\n  let i = 0;\r\n  const out =\r\n    next.length === original.length\r\n      ? middle.map((r) => {\r\n          const text = next.slice(i, i + r.text.length);\r\n          i += r.text.length;\r\n          return { text, style: r.style };\r\n        })\r\n      : middle;\r\n  return normalizeRuns([...head, ...out, ...tail], fallbackStyle(runs, start));\r\n}\r\n\r\n// ---------------------------------------------------------------------------\r\n// applyOp\r\n\r\nconst identity = (p: DocPosition): DocPosition => p;\r\n\r\n/** Content ops accept ANY paragraph (top-level or table cell). */\r\nfunction mustLocate(doc: Document, blockId: string): { loc: ParaLocation; block: Paragraph } {\r\n  const loc = locateParagraph(doc, blockId);\r\n  if (!loc) throw new Error(`paragraph ${blockId} not found`);\r\n  return { loc, block: paragraphAt(doc, loc) };\r\n}\r\n\r\n// ---- container plumbing: structural ops work on the body OR a band story ----\r\n\r\nexport function containerBlocks(doc: Document, where: Container): Block[] {\r\n  return where === \"body\" ? doc.blocks : (doc.section[where] ?? []);\r\n}\r\n\r\nfunction withContainerBlocks(doc: Document, where: Container, blocks: Block[]): Document {\r\n  if (where === \"body\") return { ...doc, blocks };\r\n  return { ...doc, section: { ...doc.section, [where]: blocks } };\r\n}\r\n\r\n/** Which container holds this TOP-LEVEL block (paragraphs in table cells are\r\n *  not top-level and return null). */\r\nexport function containerOf(doc: Document, blockId: string): { where: Container; index: number } | null {\r\n  for (const where of [\"body\", ...BAND_CONTAINERS] as Container[]) {\r\n    const index = containerBlocks(doc, where).findIndex((b) => b.id === blockId);\r\n    if (index >= 0) return { where, index };\r\n  }\r\n  return null;\r\n}\r\n\r\nfunction mustTable(doc: Document, blockId: string): { where: Container; bi: number; block: TableBlock } {\r\n  const found = containerOf(doc, blockId);\r\n  const block = found ? containerBlocks(doc, found.where)[found.index] : undefined;\r\n  if (!found || !block || block.kind !== \"table\") throw new Error(`table ${blockId} not found`);\r\n  return { where: found.where, bi: found.index, block };\r\n}\r\n\r\nfunction replaceTable(doc: Document, where: Container, bi: number, table: TableBlock): Document {\r\n  const blocks = containerBlocks(doc, where).slice();\r\n  blocks[bi] = { ...table, revision: table.revision + 1 };\r\n  return withContainerBlocks(doc, where, blocks);\r\n}\r\n\r\n/** Path-clone a table (body or band) replacing one cell's block list\r\n *  (revision bumped). */\r\nfunction replaceCellBlocks(\r\n  doc: Document,\r\n  where: Container,\r\n  bi: number,\r\n  ri: number,\r\n  ci: number,\r\n  cellBlocks: Block[],\r\n): Document {\r\n  const blocks = containerBlocks(doc, where).slice();\r\n  const table = blocks[bi] as TableBlock;\r\n  const rows = table.rows.slice();\r\n  const row = { cells: rows[ri]!.cells.slice() };\r\n  row.cells[ci] = { ...row.cells[ci]!, blocks: cellBlocks };\r\n  rows[ri] = row;\r\n  blocks[bi] = { ...table, rows, revision: table.revision + 1 };\r\n  return withContainerBlocks(doc, where, blocks);\r\n}\r\n\r\n/** First caret-capable paragraph in a set of rows (cells may start with images). */\r\nexport function firstParagraphInRows(rows: TableRow[]): Paragraph | undefined {\r\n  for (const row of rows) {\r\n    for (const cell of row.cells) {\r\n      for (const b of cell.blocks) if (b.kind === \"paragraph\") return b;\r\n    }\r\n  }\r\n  return undefined;\r\n}\r\n\r\n/** Find an image block anywhere editable: top-level containers or table cells. */\r\nexport type ImageLocation =\r\n  | { kind: \"top\"; where: Container; index: number; image: ImageBlock }\r\n  | { kind: \"cell\"; bi: number; ri: number; ci: number; ii: number; image: ImageBlock };\r\n\r\nexport function locateImage(doc: Document, blockId: string): ImageLocation | null {\r\n  const found = containerOf(doc, blockId);\r\n  if (found) {\r\n    const block = containerBlocks(doc, found.where)[found.index];\r\n    if (block?.kind === \"image\") return { kind: \"top\", where: found.where, index: found.index, image: block };\r\n    return null;\r\n  }\r\n  for (let bi = 0; bi < doc.blocks.length; bi++) {\r\n    const b = doc.blocks[bi]!;\r\n    if (b.kind !== \"table\") continue;\r\n    for (let ri = 0; ri < b.rows.length; ri++) {\r\n      const row = b.rows[ri]!;\r\n      for (let ci = 0; ci < row.cells.length; ci++) {\r\n        const cell = row.cells[ci]!;\r\n        for (let ii = 0; ii < cell.blocks.length; ii++) {\r\n          const cb = cell.blocks[ii]!;\r\n          if (cb.kind === \"image\" && cb.id === blockId) return { kind: \"cell\", bi, ri, ci, ii, image: cb };\r\n        }\r\n      }\r\n    }\r\n  }\r\n  return null;\r\n}\r\n\r\n/** Where a block lives: top-level in a container (body or a header/footer band)\r\n *  or one level deep in a table cell. The path carries the container so callers\r\n *  can clone the right story. */\r\nexport type BlockLocation<B extends Block> =\r\n  | { kind: \"top\"; where: Container; index: number; block: B }\r\n  | { kind: \"cell\"; where: Container; bi: number; ri: number; ci: number; ii: number; block: B };\r\n\r\n/** Find a block of a given kind anywhere editable \u2014 a top-level block of any\r\n *  container (body or a header/footer band) OR a block nested one level deep in\r\n *  a table cell (of a body OR band table). The container-aware generalization of\r\n *  locateImage; equation editing/alignment/deletion resolve through it so display\r\n *  equations imported into cells or bands stay live. Returns null when no block\r\n *  with that id and kind exists. */\r\nexport function locateBlock<K extends Block[\"kind\"]>(\r\n  doc: Document,\r\n  blockId: string,\r\n  blockKind: K,\r\n): BlockLocation<Extract<Block, { kind: K }>> | null {\r\n  type B = Extract<Block, { kind: K }>;\r\n  const found = containerOf(doc, blockId);\r\n  if (found) {\r\n    const block = containerBlocks(doc, found.where)[found.index];\r\n    if (block?.kind === blockKind) {\r\n      return { kind: \"top\", where: found.where, index: found.index, block: block as B };\r\n    }\r\n    return null; // id is a top-level block, but not of the requested kind\r\n  }\r\n  // Not top-level \u2014 scan table cells in the body and every band story.\r\n  for (const where of [\"body\", ...BAND_CONTAINERS] as Container[]) {\r\n    const blocks = containerBlocks(doc, where);\r\n    for (let bi = 0; bi < blocks.length; bi++) {\r\n      const b = blocks[bi]!;\r\n      if (b.kind !== \"table\") continue;\r\n      for (let ri = 0; ri < b.rows.length; ri++) {\r\n        const row = b.rows[ri]!;\r\n        for (let ci = 0; ci < row.cells.length; ci++) {\r\n          const cell = row.cells[ci]!;\r\n          for (let ii = 0; ii < cell.blocks.length; ii++) {\r\n            const cb = cell.blocks[ii]!;\r\n            if (cb.kind === blockKind && cb.id === blockId) {\r\n              return { kind: \"cell\", where, bi, ri, ci, ii, block: cb as B };\r\n            }\r\n          }\r\n        }\r\n      }\r\n    }\r\n  }\r\n  return null;\r\n}\r\n\r\n/** Locate a display-equation block anywhere editable (body / band / table cell). */\r\nexport function locateEquation(doc: Document, blockId: string): BlockLocation<EquationBlock> | null {\r\n  return locateBlock(doc, blockId, \"equation\");\r\n}\r\n\r\n/** Path-clone the document replacing a located block in place (top-level in any\r\n *  container, or one level deep in a table cell). */\r\nfunction replaceLocatedBlock(doc: Document, loc: BlockLocation<Block>, block: Block): Document {\r\n  if (loc.kind === \"top\") {\r\n    const blocks = containerBlocks(doc, loc.where).slice();\r\n    blocks[loc.index] = block;\r\n    return withContainerBlocks(doc, loc.where, blocks);\r\n  }\r\n  const table = containerBlocks(doc, loc.where)[loc.bi] as TableBlock;\r\n  const cellBlocks = table.rows[loc.ri]!.cells[loc.ci]!.blocks.slice();\r\n  cellBlocks[loc.ii] = block;\r\n  return replaceCellBlocks(doc, loc.where, loc.bi, loc.ri, loc.ci, cellBlocks);\r\n}\r\n\r\n/** The table's true grid-column count: the widest row measured in GRID columns,\r\n *  not cells \u2014 colSpan widens a cell and a rowSpan from an earlier row leaves a\r\n *  hole that this row's cells shift past (HTML table model). Counting cells\r\n *  alone undercounts any row with a colSpan or a vertical-merge hole. */\r\nexport function gridColumnCount(t: TableBlock): number {\r\n  let maxCols = 1;\r\n  const rowsRemaining: number[] = [];\r\n  for (const row of t.rows) {\r\n    let col = 0;\r\n    for (const cell of row.cells) {\r\n      while ((rowsRemaining[col] ?? 0) > 0) col++;\r\n      const span = Math.max(1, cell.colSpan ?? 1);\r\n      const rowSpan = Math.max(1, cell.rowSpan ?? 1);\r\n      if (rowSpan > 1) for (let k = 0; k < span; k++) rowsRemaining[col + k] = rowSpan;\r\n      col += span;\r\n    }\r\n    maxCols = Math.max(maxCols, col);\r\n    for (let c = 0; c < rowsRemaining.length; c++) if (rowsRemaining[c]! > 0) rowsRemaining[c]!--;\r\n  }\r\n  return maxCols;\r\n}\r\n\r\n/** Column fractions normalized to the table's column count. */\r\nexport function effectiveFractions(t: TableBlock): number[] {\r\n  const n = gridColumnCount(t);\r\n  if (t.colFractions && t.colFractions.length === n) return t.colFractions;\r\n  return Array.from({ length: n }, () => 1 / n);\r\n}\r\n\r\nfunction bump(block: Paragraph, runs: Run[]): Paragraph {\r\n  return { ...block, runs, revision: block.revision + 1 };\r\n}\r\n\r\nexport function applyOp(doc: Document, op: Op): ApplyResult {\r\n  switch (op.type) {\r\n    case \"insertText\": {\r\n      const { loc, block } = mustLocate(doc, op.at.blockId);\r\n      const runs = insertTextInRuns(block.runs, op.at.offset, op.text, op.style);\r\n      const len = op.text.length;\r\n      return {\r\n        doc: replaceParagraphAt(doc, loc, bump(block, runs)),\r\n        inverse: { type: \"deleteRange\", blockId: block.id, start: op.at.offset, end: op.at.offset + len },\r\n        mapPosition: (p) =>\r\n          p.blockId === block.id && p.offset >= op.at.offset\r\n            ? { blockId: p.blockId, offset: p.offset + len }\r\n            : p,\r\n        dirtyBlockIds: [block.id],\r\n      };\r\n    }\r\n\r\n    case \"insertRuns\": {\r\n      const { loc, block } = mustLocate(doc, op.at.blockId);\r\n      const len = textOfRuns(op.runs).length;\r\n      const runs = insertRunsInRuns(block.runs, op.at.offset, op.runs);\r\n      return {\r\n        doc: replaceParagraphAt(doc, loc, bump(block, runs)),\r\n        inverse: { type: \"deleteRange\", blockId: block.id, start: op.at.offset, end: op.at.offset + len },\r\n        mapPosition: (p) =>\r\n          p.blockId === block.id && p.offset >= op.at.offset\r\n            ? { blockId: p.blockId, offset: p.offset + len }\r\n            : p,\r\n        dirtyBlockIds: [block.id],\r\n      };\r\n    }\r\n\r\n    case \"deleteRange\": {\r\n      const { loc, block } = mustLocate(doc, op.blockId);\r\n      const removed = sliceRuns(block.runs, op.start, op.end);\r\n      const runs = deleteInRuns(block.runs, op.start, op.end);\r\n      const len = op.end - op.start;\r\n      return {\r\n        doc: replaceParagraphAt(doc, loc, bump(block, runs)),\r\n        inverse: { type: \"insertRuns\", at: { blockId: block.id, offset: op.start }, runs: removed },\r\n        mapPosition: (p) => {\r\n          if (p.blockId !== block.id || p.offset <= op.start) return p;\r\n          return { blockId: p.blockId, offset: p.offset >= op.end ? p.offset - len : op.start };\r\n        },\r\n        dirtyBlockIds: [block.id],\r\n      };\r\n    }\r\n\r\n    case \"setRuns\": {\r\n      const { loc, block } = mustLocate(doc, op.blockId);\r\n      return {\r\n        doc: replaceParagraphAt(doc, loc, bump(block, op.runs)),\r\n        inverse: { type: \"setRuns\", blockId: block.id, runs: block.runs },\r\n        mapPosition: identity, // callers use setRuns for length-preserving restyles\r\n        dirtyBlockIds: [block.id],\r\n      };\r\n    }\r\n\r\n    case \"setParaStyle\": {\r\n      const { loc, block } = mustLocate(doc, op.blockId);\r\n      const oldPatch: Partial<ParaStyle> = {};\r\n      for (const key of Object.keys(op.patch) as (keyof ParaStyle)[]) {\r\n        // @ts-expect-error \u2014 keyed copy of the previous values for the inverse\r\n        oldPatch[key] = block.style[key];\r\n      }\r\n      const styled: Paragraph = {\r\n        ...block,\r\n        style: { ...block.style, ...op.patch },\r\n        revision: block.revision + 1,\r\n      };\r\n      return {\r\n        doc: replaceParagraphAt(doc, loc, styled),\r\n        inverse: { type: \"setParaStyle\", blockId: block.id, patch: oldPatch },\r\n        mapPosition: identity,\r\n        dirtyBlockIds: [block.id],\r\n      };\r\n    }\r\n\r\n    case \"splitParagraph\": {\r\n      const loc = locateParagraph(doc, op.at.blockId);\r\n      if (!loc) throw new Error(`paragraph ${op.at.blockId} not found`);\r\n      const block = paragraphAt(doc, loc);\r\n      const [headRuns, tailRuns] = splitRunsAt(block.runs, op.at.offset);\r\n      const carry = fallbackStyle(block.runs, op.at.offset);\r\n      const head = bump(block, normalizeRuns(headRuns, carry));\r\n      const tail: Paragraph = {\r\n        kind: \"paragraph\",\r\n        id: op.newBlockId,\r\n        revision: 0,\r\n        runs: normalizeRuns(tailRuns, carry),\r\n        style: op.newStyle ?? { ...block.style },\r\n        // The tail's block-level content control is declared by the op (the split\r\n        // command carries the source paragraph's path; the merge inverse restores\r\n        // the original tail's). Absent \u2192 the tail belongs to no block control.\r\n        ...(op.newSdtPath?.length ? { sdtPath: op.newSdtPath } : {}),\r\n      };\r\n      let next: Document;\r\n      if (loc.kind === \"cell\") {\r\n        const table = containerBlocks(doc, loc.where)[loc.bi] as TableBlock;\r\n        const cellBlocks = table.rows[loc.ri]!.cells[loc.ci]!.blocks.slice();\r\n        cellBlocks.splice(loc.pi, 1, head, tail);\r\n        next = replaceCellBlocks(doc, loc.where, loc.bi, loc.ri, loc.ci, cellBlocks);\r\n      } else if (loc.kind === \"footnote\") {\r\n        const paras = doc.footnotes![loc.noteId]!.slice();\r\n        paras.splice(loc.pi, 1, head, tail);\r\n        next = { ...doc, footnotes: { ...doc.footnotes, [loc.noteId]: paras } };\r\n      } else if (loc.kind === \"endnote\") {\r\n        const paras = doc.endnotes![loc.noteId]!.slice();\r\n        paras.splice(loc.pi, 1, head, tail);\r\n        next = { ...doc, endnotes: { ...doc.endnotes, [loc.noteId]: paras } };\r\n      } else {\r\n        const where: Container = loc.kind === \"band\" ? loc.band : \"body\";\r\n        const blocks = containerBlocks(doc, where).slice();\r\n        blocks.splice(loc.bi, 1, head, tail);\r\n        next = withContainerBlocks(doc, where, blocks);\r\n      }\r\n      return {\r\n        doc: next,\r\n        inverse: { type: \"mergeParagraphs\", firstBlockId: block.id },\r\n        mapPosition: (p) =>\r\n          p.blockId === block.id && p.offset >= op.at.offset\r\n            ? { blockId: op.newBlockId, offset: p.offset - op.at.offset }\r\n            : p,\r\n        dirtyBlockIds: [block.id, op.newBlockId],\r\n      };\r\n    }\r\n\r\n    case \"mergeParagraphs\": {\r\n      const loc = locateParagraph(doc, op.firstBlockId);\r\n      if (!loc) throw new Error(`paragraph ${op.firstBlockId} not found`);\r\n      const block = paragraphAt(doc, loc);\r\n      let nextPara: Paragraph;\r\n      if (loc.kind === \"cell\") {\r\n        const table = containerBlocks(doc, loc.where)[loc.bi] as TableBlock;\r\n        const candidate = table.rows[loc.ri]!.cells[loc.ci]!.blocks[loc.pi + 1];\r\n        if (!candidate || candidate.kind !== \"paragraph\") {\r\n          throw new Error(\"mergeParagraphs: no next paragraph in cell\");\r\n        }\r\n        nextPara = candidate;\r\n      } else if (loc.kind === \"footnote\") {\r\n        const candidate = doc.footnotes![loc.noteId]![loc.pi + 1];\r\n        if (!candidate) throw new Error(\"mergeParagraphs: no next paragraph in footnote\");\r\n        nextPara = candidate;\r\n      } else if (loc.kind === \"endnote\") {\r\n        const candidate = doc.endnotes![loc.noteId]![loc.pi + 1];\r\n        if (!candidate) throw new Error(\"mergeParagraphs: no next paragraph in endnote\");\r\n        nextPara = candidate;\r\n      } else {\r\n        const where: Container = loc.kind === \"band\" ? loc.band : \"body\";\r\n        const candidate = containerBlocks(doc, where)[loc.bi + 1];\r\n        if (!candidate || candidate.kind !== \"paragraph\") {\r\n          throw new Error(\"mergeParagraphs: no next paragraph\");\r\n        }\r\n        nextPara = candidate;\r\n      }\r\n      const headLen = textOfRuns(block.runs).length;\r\n      const merged = bump(\r\n        block,\r\n        normalizeRuns([...block.runs, ...nextPara.runs], fallbackStyle(block.runs, headLen)),\r\n      );\r\n      let next: Document;\r\n      if (loc.kind === \"cell\") {\r\n        const table = containerBlocks(doc, loc.where)[loc.bi] as TableBlock;\r\n        const cellBlocks = table.rows[loc.ri]!.cells[loc.ci]!.blocks.slice();\r\n        cellBlocks.splice(loc.pi, 2, merged);\r\n        next = replaceCellBlocks(doc, loc.where, loc.bi, loc.ri, loc.ci, cellBlocks);\r\n      } else if (loc.kind === \"footnote\") {\r\n        const paras = doc.footnotes![loc.noteId]!.slice();\r\n        paras.splice(loc.pi, 2, merged);\r\n        next = { ...doc, footnotes: { ...doc.footnotes, [loc.noteId]: paras } };\r\n      } else if (loc.kind === \"endnote\") {\r\n        const paras = doc.endnotes![loc.noteId]!.slice();\r\n        paras.splice(loc.pi, 2, merged);\r\n        next = { ...doc, endnotes: { ...doc.endnotes, [loc.noteId]: paras } };\r\n      } else {\r\n        const where: Container = loc.kind === \"band\" ? loc.band : \"body\";\r\n        const blocks = containerBlocks(doc, where).slice();\r\n        blocks.splice(loc.bi, 2, merged);\r\n        next = withContainerBlocks(doc, where, blocks);\r\n      }\r\n      return {\r\n        doc: next,\r\n        inverse: {\r\n          type: \"splitParagraph\",\r\n          at: { blockId: block.id, offset: headLen },\r\n          newBlockId: nextPara.id,\r\n          newStyle: nextPara.style,\r\n          // Restore the merged-away tail's block-level control on undo.\r\n          ...(nextPara.sdtPath?.length ? { newSdtPath: nextPara.sdtPath } : {}),\r\n        },\r\n        mapPosition: (p) =>\r\n          p.blockId === nextPara.id ? { blockId: block.id, offset: headLen + p.offset } : p,\r\n        dirtyBlockIds: [block.id, nextPara.id],\r\n      };\r\n    }\r\n\r\n    case \"insertBlock\": {\r\n      const where = op.where ?? \"body\";\r\n      const blocks = containerBlocks(doc, where).slice();\r\n      blocks.splice(op.index, 0, op.block);\r\n      return {\r\n        doc: withContainerBlocks(doc, where, blocks),\r\n        inverse: { type: \"removeBlock\", blockId: op.block.id },\r\n        mapPosition: identity,\r\n        dirtyBlockIds: [op.block.id],\r\n      };\r\n    }\r\n\r\n    case \"removeBlock\": {\r\n      const found = containerOf(doc, op.blockId);\r\n      if (!found) throw new Error(`block ${op.blockId} not found`);\r\n      const blocks = containerBlocks(doc, found.where).slice();\r\n      const block = blocks[found.index]!;\r\n      blocks.splice(found.index, 1);\r\n      const neighbor = blocks[Math.min(found.index, blocks.length - 1)];\r\n      return {\r\n        doc: withContainerBlocks(doc, found.where, blocks),\r\n        inverse: { type: \"insertBlock\", index: found.index, block, where: found.where },\r\n        mapPosition: (p) =>\r\n          p.blockId === op.blockId && neighbor\r\n            ? { blockId: neighbor.id, offset: 0 }\r\n            : p,\r\n        dirtyBlockIds: [op.blockId],\r\n      };\r\n    }\r\n\r\n    case \"setImageProps\": {\r\n      const loc = locateImage(doc, op.blockId);\r\n      if (!loc) throw new Error(`image ${op.blockId} not found`);\r\n      const block = loc.image;\r\n      // Inverse restores prior values; a field absent before is cleared (null)\r\n      // on undo. wrap/anchor use null to mean \"clear\" (they're exclusive states).\r\n      const oldPatch: ImagePropsPatch = {};\r\n      if (op.patch.widthPx !== undefined) oldPatch.widthPx = block.widthPx;\r\n      if (op.patch.heightPx !== undefined) oldPatch.heightPx = block.heightPx;\r\n      if (op.patch.align !== undefined) oldPatch.align = block.align;\r\n      if (op.patch.wrap !== undefined) oldPatch.wrap = block.wrap ?? null;\r\n      if (op.patch.anchor !== undefined) oldPatch.anchor = block.anchor ?? null;\r\n      if (op.patch.crop !== undefined) oldPatch.crop = block.crop ?? null;\r\n      const updated: ImageBlock = { ...block, revision: block.revision + 1 };\r\n      if (op.patch.widthPx !== undefined) updated.widthPx = op.patch.widthPx;\r\n      if (op.patch.heightPx !== undefined) updated.heightPx = op.patch.heightPx;\r\n      if (op.patch.align !== undefined) updated.align = op.patch.align;\r\n      if (op.patch.wrap !== undefined) {\r\n        if (op.patch.wrap === null) delete updated.wrap;\r\n        else updated.wrap = op.patch.wrap;\r\n      }\r\n      if (op.patch.anchor !== undefined) {\r\n        if (op.patch.anchor === null) delete updated.anchor;\r\n        else updated.anchor = op.patch.anchor;\r\n      }\r\n      if (op.patch.crop !== undefined) {\r\n        if (op.patch.crop === null) delete updated.crop;\r\n        else updated.crop = normalizeCrop(op.patch.crop);\r\n      }\r\n      let next: Document;\r\n      if (loc.kind === \"top\") {\r\n        const blocks = containerBlocks(doc, loc.where).slice();\r\n        blocks[loc.index] = updated;\r\n        next = withContainerBlocks(doc, loc.where, blocks);\r\n      } else {\r\n        const table = doc.blocks[loc.bi] as TableBlock;\r\n        const cellBlocks = table.rows[loc.ri]!.cells[loc.ci]!.blocks.slice();\r\n        cellBlocks[loc.ii] = updated;\r\n        next = replaceCellBlocks(doc, \"body\", loc.bi, loc.ri, loc.ci, cellBlocks); // locateImage cells are body-only\r\n\r\n      }\r\n      return {\r\n        doc: next,\r\n        inverse: { type: \"setImageProps\", blockId: op.blockId, patch: oldPatch },\r\n        mapPosition: identity,\r\n        dirtyBlockIds: [op.blockId],\r\n      };\r\n    }\r\n\r\n    case \"setEquation\": {\r\n      // Replace a display equation's MathML (the editor's Apply). Container-aware:\r\n      // the equation may live in the body, a header/footer band, or a table cell.\r\n      const loc = locateEquation(doc, op.blockId);\r\n      if (!loc) throw new Error(`equation ${op.blockId} not found`);\r\n      const old = loc.block.equation;\r\n      const updated: EquationBlock = { ...loc.block, revision: loc.block.revision + 1, equation: op.equation };\r\n      return {\r\n        doc: replaceLocatedBlock(doc, loc, updated),\r\n        inverse: { type: \"setEquation\", blockId: op.blockId, equation: old },\r\n        mapPosition: identity,\r\n        dirtyBlockIds: [op.blockId],\r\n      };\r\n    }\r\n\r\n    case \"setEquationAlign\": {\r\n      const loc = locateEquation(doc, op.blockId);\r\n      if (!loc) throw new Error(`equation ${op.blockId} not found`);\r\n      const old = loc.block.align ?? \"center\";\r\n      const updated: EquationBlock = { ...loc.block, revision: loc.block.revision + 1, align: op.align };\r\n      return {\r\n        doc: replaceLocatedBlock(doc, loc, updated),\r\n        inverse: { type: \"setEquationAlign\", blockId: op.blockId, align: old },\r\n        mapPosition: identity,\r\n        dirtyBlockIds: [op.blockId],\r\n      };\r\n    }\r\n\r\n    case \"setTableColFractions\": {\r\n      const { where, bi, block } = mustTable(doc, op.blockId);\r\n      const old = effectiveFractions(block);\r\n      return {\r\n        doc: replaceTable(doc, where, bi, { ...block, colFractions: op.fractions }),\r\n        inverse: { type: \"setTableColFractions\", blockId: op.blockId, fractions: old },\r\n        mapPosition: identity,\r\n        dirtyBlockIds: [op.blockId],\r\n      };\r\n    }\r\n\r\n    case \"setTableWidthMode\": {\r\n      const { where, bi, block } = mustTable(doc, op.blockId);\r\n      const old = block.widthMode;\r\n      const next: TableBlock = { ...block };\r\n      if (op.mode && op.mode !== \"fixed\") next.widthMode = op.mode;\r\n      else delete next.widthMode;\r\n      return {\r\n        doc: replaceTable(doc, where, bi, next),\r\n        inverse: { type: \"setTableWidthMode\", blockId: op.blockId, mode: old },\r\n        mapPosition: identity,\r\n        dirtyBlockIds: [op.blockId],\r\n      };\r\n    }\r\n\r\n    case \"setTablePreferredWidth\": {\r\n      const { where, bi, block } = mustTable(doc, op.blockId);\r\n      const old = block.preferredWidth;\r\n      const next: TableBlock = { ...block };\r\n      if (op.width) next.preferredWidth = op.width;\r\n      else delete next.preferredWidth;\r\n      return {\r\n        doc: replaceTable(doc, where, bi, next),\r\n        inverse: { type: \"setTablePreferredWidth\", blockId: op.blockId, width: old ?? null },\r\n        mapPosition: identity,\r\n        dirtyBlockIds: [op.blockId],\r\n      };\r\n    }\r\n\r\n    case \"setTableAlign\": {\r\n      const { where, bi, block } = mustTable(doc, op.blockId);\r\n      const old = block.align;\r\n      const next: TableBlock = { ...block };\r\n      if (op.align && op.align !== \"left\") next.align = op.align;\r\n      else delete next.align;\r\n      return {\r\n        doc: replaceTable(doc, where, bi, next),\r\n        inverse: { type: \"setTableAlign\", blockId: op.blockId, align: old ?? null },\r\n        mapPosition: identity,\r\n        dirtyBlockIds: [op.blockId],\r\n      };\r\n    }\r\n\r\n    case \"setTableProps\": {\r\n      // Table-LEVEL props (indent + cascade defaults). Patch keys present are\r\n      // applied (a value sets, `null` clears); the inverse captures each touched\r\n      // field's prior value (null = was absent) so undo restores it exactly.\r\n      const { where, bi, block } = mustTable(doc, op.blockId);\r\n      const keys = Object.keys(op.patch) as (keyof TablePropsPatch)[];\r\n      const oldPatch: TablePropsPatch = {};\r\n      const next: Record<string, unknown> = { ...block };\r\n      const blockRec = block as unknown as Record<string, unknown>;\r\n      const oldRec = oldPatch as Record<string, unknown>;\r\n      for (const key of keys) {\r\n        oldRec[key] = blockRec[key] ?? null;\r\n        const val = op.patch[key];\r\n        if (val === undefined || val === null) delete next[key];\r\n        else next[key] = val;\r\n      }\r\n      return {\r\n        doc: replaceTable(doc, where, bi, next as unknown as TableBlock),\r\n        inverse: { type: \"setTableProps\", blockId: op.blockId, patch: oldPatch },\r\n        mapPosition: identity,\r\n        dirtyBlockIds: [op.blockId],\r\n      };\r\n    }\r\n\r\n    case \"setTableRow\": {\r\n      const { where, bi, block } = mustTable(doc, op.tableId);\r\n      const old = block.rows[op.rowIndex];\r\n      if (!old) throw new Error(\"setTableRow: no such row\");\r\n      const removedIds = new Set(old.cells.flatMap((c) => c.blocks.map((p) => p.id)));\r\n      const rows = block.rows.slice();\r\n      rows[op.rowIndex] = op.row;\r\n      const fallback = firstParagraphInRows([op.row]);\r\n      return {\r\n        doc: replaceTable(doc, where, bi, { ...block, rows }),\r\n        inverse: { type: \"setTableRow\", tableId: op.tableId, rowIndex: op.rowIndex, row: old },\r\n        mapPosition: (p) => {\r\n          if (!removedIds.has(p.blockId)) return p;\r\n          // position survives if its paragraph still exists in the new row\r\n          const kept = op.row.cells.some((c) => c.blocks.some((b) => b.id === p.blockId));\r\n          return kept || !fallback ? p : { blockId: fallback.id, offset: 0 };\r\n        },\r\n        dirtyBlockIds: [op.tableId],\r\n      };\r\n    }\r\n\r\n    case \"insertTableRow\": {\r\n      const { where, bi, block } = mustTable(doc, op.tableId);\r\n      const rows = block.rows.slice();\r\n      rows.splice(op.rowIndex, 0, op.row);\r\n      return {\r\n        doc: replaceTable(doc, where, bi, { ...block, rows }),\r\n        inverse: { type: \"removeTableRow\", tableId: op.tableId, rowIndex: op.rowIndex },\r\n        mapPosition: identity,\r\n        dirtyBlockIds: [op.tableId],\r\n      };\r\n    }\r\n\r\n    case \"removeTableRow\": {\r\n      const { where, bi, block } = mustTable(doc, op.tableId);\r\n      const removed = block.rows[op.rowIndex];\r\n      if (!removed) throw new Error(\"removeTableRow: no such row\");\r\n      const rows = block.rows.slice();\r\n      rows.splice(op.rowIndex, 1);\r\n      const removedIds = new Set(removed.cells.flatMap((c) => c.blocks.map((p) => p.id)));\r\n      const fallbackRow = rows[Math.min(op.rowIndex, rows.length - 1)];\r\n      const fallback = fallbackRow ? firstParagraphInRows([fallbackRow]) : undefined;\r\n      return {\r\n        doc: replaceTable(doc, where, bi, { ...block, rows }),\r\n        inverse: { type: \"insertTableRow\", tableId: op.tableId, rowIndex: op.rowIndex, row: removed },\r\n        mapPosition: (p) =>\r\n          removedIds.has(p.blockId) && fallback ? { blockId: fallback.id, offset: 0 } : p,\r\n        dirtyBlockIds: [op.tableId],\r\n      };\r\n    }\r\n\r\n    case \"setRowHeight\": {\r\n      // Interactive row-drag height (w:trHeight). Mirrors the column op: replace a\r\n      // single row's `props.height`, leaving the rest of its props untouched, and\r\n      // invert to the prior height (null = none) for a free undo.\r\n      const { where, bi, block } = mustTable(doc, op.tableId);\r\n      const row = block.rows[op.rowIndex];\r\n      if (!row) throw new Error(\"setRowHeight: no such row\");\r\n      const old = row.props?.height ?? null;\r\n      const nextRow: TableRow = { ...row };\r\n      const props: RowProps = { ...(row.props ?? {}) };\r\n      if (op.height) props.height = op.height;\r\n      else delete props.height;\r\n      if (Object.keys(props).length) nextRow.props = props;\r\n      else delete nextRow.props;\r\n      const rows = block.rows.slice();\r\n      rows[op.rowIndex] = nextRow;\r\n      return {\r\n        doc: replaceTable(doc, where, bi, { ...block, rows }),\r\n        inverse: { type: \"setRowHeight\", tableId: op.tableId, rowIndex: op.rowIndex, height: old },\r\n        mapPosition: identity,\r\n        dirtyBlockIds: [op.tableId],\r\n      };\r\n    }\r\n\r\n    case \"setListDefinition\": {\r\n      const old = doc.lists?.[op.listId] ?? null;\r\n      const lists = { ...(doc.lists ?? {}) };\r\n      if (op.def) lists[op.listId] = op.def;\r\n      else delete lists[op.listId];\r\n      return {\r\n        doc: { ...doc, lists },\r\n        inverse: { type: \"setListDefinition\", listId: op.listId, def: old },\r\n        mapPosition: identity,\r\n        // Indents come from the definition \u2192 every paragraph in the list must\r\n        // re-measure; their (revision,width) line-cache keys change with width.\r\n        dirtyBlockIds: [],\r\n      };\r\n    }\r\n\r\n    case \"setTableStructure\": {\r\n      const { where, bi, block } = mustTable(doc, op.tableId);\r\n      const oldIds = new Set(\r\n        block.rows.flatMap((r) => r.cells.flatMap((c) => c.blocks.map((p) => p.id))),\r\n      );\r\n      const fallback = firstParagraphInRows(op.rows);\r\n      const next: TableBlock = { ...block, rows: op.rows };\r\n      if (op.colFractions) next.colFractions = op.colFractions;\r\n      else delete next.colFractions;\r\n      const inverse: Op = { type: \"setTableStructure\", tableId: op.tableId, rows: block.rows };\r\n      if (block.colFractions) inverse.colFractions = block.colFractions;\r\n      return {\r\n        doc: replaceTable(doc, where, bi, next),\r\n        inverse,\r\n        mapPosition: (p) => {\r\n          if (!oldIds.has(p.blockId)) return p;\r\n          const kept = op.rows.some((r) =>\r\n            r.cells.some((c) => c.blocks.some((b) => b.id === p.blockId)),\r\n          );\r\n          return kept || !fallback ? p : { blockId: fallback.id, offset: 0 };\r\n        },\r\n        dirtyBlockIds: [op.tableId],\r\n      };\r\n    }\r\n\r\n    case \"insertTableColumn\": {\r\n      const { where, bi, block } = mustTable(doc, op.tableId);\r\n      const snapshot: Op = { type: \"setTableStructure\", tableId: op.tableId, rows: block.rows };\r\n      if (block.colFractions) snapshot.colFractions = block.colFractions;\r\n      // Span-aware: a merged cell covering the insertion point grows by one\r\n      // column instead of having a new cell slotted into its middle.\r\n      const rows = block.rows.map((row, ri) => {\r\n        const cells: TableCell[] = [];\r\n        let col = 0;\r\n        let inserted = false;\r\n        for (const cell of row.cells) {\r\n          const span = cell.colSpan ?? 1;\r\n          if (!inserted && op.colIndex > col && op.colIndex < col + span) {\r\n            cells.push({ ...cell, colSpan: span + 1 });\r\n            inserted = true;\r\n          } else if (!inserted && op.colIndex === col) {\r\n            const fresh = op.cells[ri];\r\n            if (fresh) cells.push(fresh);\r\n            cells.push(cell);\r\n            inserted = true;\r\n          } else {\r\n            cells.push(cell);\r\n          }\r\n          col += span;\r\n        }\r\n        if (!inserted) {\r\n          const fresh = op.cells[ri];\r\n          if (fresh) cells.push(fresh); // append at the right edge\r\n        }\r\n        return { cells };\r\n      });\r\n      let fractions = op.fractions;\r\n      if (!fractions) {\r\n        const old = effectiveFractions(block);\r\n        const fresh = 1 / (old.length + 1);\r\n        fractions = old.map((f) => f * (1 - fresh));\r\n        fractions.splice(op.colIndex, 0, fresh);\r\n      }\r\n      return {\r\n        doc: replaceTable(doc, where, bi, { ...block, rows, colFractions: fractions }),\r\n        inverse: snapshot,\r\n        mapPosition: identity,\r\n        dirtyBlockIds: [op.tableId],\r\n      };\r\n    }\r\n\r\n    case \"setStylesheet\": {\r\n      const old = doc.stylesheet ?? { styles: [], defaultStyleId: \"Normal\" };\r\n      return {\r\n        doc: { ...doc, stylesheet: op.stylesheet },\r\n        inverse: { type: \"setStylesheet\", stylesheet: old },\r\n        mapPosition: identity,\r\n        dirtyBlockIds: [], // restyling paragraphs happens via setRuns/setParaStyle ops\r\n      };\r\n    }\r\n\r\n    case \"setTableStyleSheet\": {\r\n      const old = doc.tableStyles ?? {};\r\n      return {\r\n        doc: { ...doc, tableStyles: op.tableStyles },\r\n        inverse: { type: \"setTableStyleSheet\", tableStyles: old },\r\n        mapPosition: identity,\r\n        dirtyBlockIds: [], // re-baking cells happens via the table-replace ops\r\n      };\r\n    }\r\n\r\n    case \"setTableStyleRef\": {\r\n      const { where, bi, block } = mustTable(doc, op.tableId);\r\n      const oldStyleId = block.styleId ?? null;\r\n      const oldCond = block.condOverrides ?? null;\r\n      const next: TableBlock = { ...block };\r\n      if (op.styleId === null) delete next.styleId;\r\n      else next.styleId = op.styleId;\r\n      if (op.condOverrides !== undefined) {\r\n        if (op.condOverrides === null) delete next.condOverrides;\r\n        else next.condOverrides = op.condOverrides;\r\n      }\r\n      return {\r\n        doc: replaceTable(doc, where, bi, next),\r\n        inverse: { type: \"setTableStyleRef\", tableId: op.tableId, styleId: oldStyleId, condOverrides: oldCond },\r\n        mapPosition: identity,\r\n        dirtyBlockIds: [op.tableId],\r\n      };\r\n    }\r\n\r\n    case \"setSectionProps\": {\r\n      const s = doc.section;\r\n      const old: SectionGeometry = {\r\n        pageWidthPx: s.pageWidthPx,\r\n        pageHeightPx: s.pageHeightPx,\r\n        marginPx: { ...s.marginPx },\r\n        columns: s.columns\r\n          ? { ...s.columns, ...(s.columns.cols ? { cols: s.columns.cols.map((c) => ({ ...c })) } : {}) }\r\n          : null,\r\n        pageNumberStart: s.pageNumberStart ?? null,\r\n        headerDistancePx: s.headerDistancePx ?? null,\r\n        footerDistancePx: s.footerDistancePx ?? null,\r\n        pageColorHex: s.pageColorHex ?? null,\r\n        pageBorders: s.pageBorders ?? null,\r\n        breakType: s.breakType ?? null,\r\n        lineNumbering: s.lineNumbering ? { ...s.lineNumbering } : null,\r\n      };\r\n      const next = {\r\n        ...s,\r\n        pageWidthPx: op.geometry.pageWidthPx,\r\n        pageHeightPx: op.geometry.pageHeightPx,\r\n        marginPx: op.geometry.marginPx,\r\n      };\r\n      if (op.geometry.columns) next.columns = op.geometry.columns;\r\n      else delete next.columns;\r\n      if (op.geometry.pageNumberStart !== null) next.pageNumberStart = op.geometry.pageNumberStart;\r\n      else delete next.pageNumberStart;\r\n      if (op.geometry.headerDistancePx !== null) next.headerDistancePx = op.geometry.headerDistancePx;\r\n      else delete next.headerDistancePx;\r\n      if (op.geometry.footerDistancePx !== null) next.footerDistancePx = op.geometry.footerDistancePx;\r\n      else delete next.footerDistancePx;\r\n      if (op.geometry.pageColorHex !== null) next.pageColorHex = op.geometry.pageColorHex;\r\n      else delete next.pageColorHex;\r\n      if (op.geometry.pageBorders !== null) next.pageBorders = op.geometry.pageBorders;\r\n      else delete next.pageBorders;\r\n      if (op.geometry.breakType !== null) next.breakType = op.geometry.breakType;\r\n      else delete next.breakType;\r\n      if (op.geometry.lineNumbering !== null) next.lineNumbering = op.geometry.lineNumbering;\r\n      else delete next.lineNumbering;\r\n      return {\r\n        doc: { ...doc, section: next },\r\n        inverse: { type: \"setSectionProps\", geometry: old },\r\n        mapPosition: identity,\r\n        dirtyBlockIds: [], // geometry change \u2192 full re-walk; line caches keyed by width\r\n      };\r\n    }\r\n\r\n    case \"setFootnote\": {\r\n      const old = doc.footnotes?.[op.noteId] ?? null;\r\n      const footnotes = { ...(doc.footnotes ?? {}) };\r\n      if (op.paras) footnotes[op.noteId] = op.paras;\r\n      else delete footnotes[op.noteId];\r\n      const removedIds = new Set((old ?? []).map((p) => p.id));\r\n      const fallback = doc.blocks.find((b) => b.kind === \"paragraph\");\r\n      return {\r\n        doc: { ...doc, footnotes },\r\n        inverse: { type: \"setFootnote\", noteId: op.noteId, paras: old },\r\n        mapPosition: (p) => {\r\n          if (!removedIds.has(p.blockId)) return p;\r\n          const kept = (op.paras ?? []).some((b) => b.id === p.blockId);\r\n          return kept || !fallback ? p : { blockId: fallback.id, offset: 0 };\r\n        },\r\n        dirtyBlockIds: [],\r\n      };\r\n    }\r\n\r\n    case \"setEndnote\": {\r\n      const old = doc.endnotes?.[op.noteId] ?? null;\r\n      const endnotes = { ...(doc.endnotes ?? {}) };\r\n      if (op.paras) endnotes[op.noteId] = op.paras;\r\n      else delete endnotes[op.noteId];\r\n      const removedIds = new Set((old ?? []).map((p) => p.id));\r\n      const fallback = doc.blocks.find((b) => b.kind === \"paragraph\");\r\n      return {\r\n        doc: { ...doc, endnotes },\r\n        inverse: { type: \"setEndnote\", noteId: op.noteId, paras: old },\r\n        mapPosition: (p) => {\r\n          if (!removedIds.has(p.blockId)) return p;\r\n          const kept = (op.paras ?? []).some((b) => b.id === p.blockId);\r\n          return kept || !fallback ? p : { blockId: fallback.id, offset: 0 };\r\n        },\r\n        dirtyBlockIds: [],\r\n      };\r\n    }\r\n\r\n    case \"setSdtProps\": {\r\n      const old = doc.sdts?.[op.id] ?? null;\r\n      const sdts = { ...(doc.sdts ?? {}) };\r\n      if (op.props) sdts[op.id] = op.props;\r\n      else delete sdts[op.id];\r\n      return {\r\n        doc: { ...doc, sdts },\r\n        inverse: { type: \"setSdtProps\", id: op.id, props: old },\r\n        mapPosition: identity,\r\n        dirtyBlockIds: [], // run markers change via setRuns/applyStylePatch ops\r\n      };\r\n    }\r\n\r\n    case \"setField\": {\r\n      const old = doc.fields?.[op.id] ?? null;\r\n      const fields = { ...(doc.fields ?? {}) };\r\n      if (op.def) fields[op.id] = op.def;\r\n      else delete fields[op.id];\r\n      return {\r\n        doc: { ...doc, fields },\r\n        inverse: { type: \"setField\", id: op.id, def: old },\r\n        mapPosition: identity,\r\n        dirtyBlockIds: [], // run/block fieldId markers change via setRuns/insert ops\r\n      };\r\n    }\r\n\r\n    case \"setTocInstruction\": {\r\n      const old = doc.tocInstruction ?? null;\r\n      const next = { ...doc };\r\n      if (op.instruction !== null) next.tocInstruction = op.instruction;\r\n      else delete next.tocInstruction;\r\n      return {\r\n        doc: next,\r\n        inverse: { type: \"setTocInstruction\", instruction: old },\r\n        mapPosition: identity,\r\n        dirtyBlockIds: [], // entries are regenerated via insert/removeBlock ops in the same tx\r\n      };\r\n    }\r\n\r\n    case \"setBookmark\": {\r\n      const old = doc.bookmarks?.[op.name] ?? null;\r\n      const bookmarks = { ...(doc.bookmarks ?? {}) };\r\n      if (op.range) bookmarks[op.name] = op.range;\r\n      else delete bookmarks[op.name];\r\n      return {\r\n        doc: { ...doc, bookmarks },\r\n        inverse: { type: \"setBookmark\", name: op.name, range: old },\r\n        mapPosition: identity,\r\n        dirtyBlockIds: [],\r\n      };\r\n    }\r\n\r\n    case \"setSectionBand\": {\r\n      const old = doc.section[op.band] ?? null;\r\n      const section = { ...doc.section };\r\n      if (op.blocks) section[op.band] = op.blocks;\r\n      else delete section[op.band];\r\n      const removedIds = new Set(\r\n        (old ?? []).filter((b) => b.kind === \"paragraph\").map((b) => b.id),\r\n      );\r\n      const fallback = doc.blocks.find((b) => b.kind === \"paragraph\");\r\n      return {\r\n        doc: { ...doc, section },\r\n        inverse: { type: \"setSectionBand\", band: op.band, blocks: old },\r\n        mapPosition: (p) => {\r\n          if (!removedIds.has(p.blockId)) return p;\r\n          const kept = (op.blocks ?? []).some((b) => b.id === p.blockId);\r\n          return kept || !fallback ? p : { blockId: fallback.id, offset: 0 };\r\n        },\r\n        dirtyBlockIds: [],\r\n      };\r\n    }\r\n\r\n    case \"removeTableColumn\": {\r\n      const { where, bi, block } = mustTable(doc, op.tableId);\r\n      const snapshot: Op = { type: \"setTableStructure\", tableId: op.tableId, rows: block.rows };\r\n      if (block.colFractions) snapshot.colFractions = block.colFractions;\r\n      const oldFractions = effectiveFractions(block);\r\n      const removedIds = new Set<string>();\r\n      // Span-aware: a merged cell covering the removed column shrinks; an\r\n      // unmerged cell at that column is dropped.\r\n      const rows = block.rows.map((row) => {\r\n        const cells: TableCell[] = [];\r\n        let col = 0;\r\n        for (const cell of row.cells) {\r\n          const span = cell.colSpan ?? 1;\r\n          if (op.colIndex >= col && op.colIndex < col + span) {\r\n            if (span > 1) {\r\n              const shrunk: TableCell = { ...cell };\r\n              if (span - 1 > 1) shrunk.colSpan = span - 1;\r\n              else delete shrunk.colSpan;\r\n              cells.push(shrunk);\r\n            } else {\r\n              for (const p of cell.blocks) removedIds.add(p.id);\r\n            }\r\n          } else {\r\n            cells.push(cell);\r\n          }\r\n          col += span;\r\n        }\r\n        return { cells };\r\n      });\r\n      const rest = oldFractions.filter((_, i) => i !== op.colIndex);\r\n      const sum = rest.reduce((s, f) => s + f, 0) || 1;\r\n      const fractions = rest.map((f) => f / sum);\r\n      const fallback = firstParagraphInRows(rows);\r\n      return {\r\n        doc: replaceTable(doc, where, bi, { ...block, rows, colFractions: fractions }),\r\n        inverse: snapshot,\r\n        mapPosition: (p) =>\r\n          removedIds.has(p.blockId) && fallback ? { blockId: fallback.id, offset: 0 } : p,\r\n        dirtyBlockIds: [op.tableId],\r\n      };\r\n    }\r\n  }\r\n}\r\n", "// Globally-unique id minting for blocks, cells, and other model nodes.\n//\n// In single-user mode any unique string works. For multi-user collaboration two\n// clients must NEVER mint the same id (a collision would make one client's\n// paragraph silently alias another's), so ids are namespaced by a per-session\n// `siteId`:\n//\n//   <siteId>-<counter base36>      e.g.  \"a3f9c1-0\", \"a3f9c1-1\", \u2026\n//\n// The counter is monotonic within a session; the siteId makes the whole space\n// disjoint from every other session. Replaying an op stream is deterministic\n// because generated ids are captured IN the op (splitParagraph.newBlockId,\n// insertBlock.block.id), so the consumer never re-mints them.\n//\n// Randomness lives at the edges (the frontend mints a siteId via crypto), not\n// here \u2014 this module stays pure and deterministic so it is trivially testable.\n\nexport interface IdGenerator {\n  readonly siteId: string;\n  /** Next unique id in this site's space. */\n  next(): string;\n  /** Current counter value (for persisting/resuming a session's id space). */\n  count(): number;\n}\n\nexport function createIdGenerator(siteId: string, start = 0): IdGenerator {\n  let n = start;\n  return {\n    siteId,\n    next: () => `${siteId}-${(n++).toString(36)}`,\n    count: () => n,\n  };\n}\n\n// A process-wide default generator. The frontend reconfigures it at startup with\n// a real siteId (see configureIds); tests and any unconfigured context get the\n// deterministic \"local\" space.\nlet active: IdGenerator = createIdGenerator(\"local\");\n\n/** Point the default generator at a session's siteId. Call once at startup,\n *  before any ids are minted. `start` resumes a prior session's counter. */\nexport function configureIds(siteId: string, start = 0): void {\n  active = createIdGenerator(siteId, start);\n}\n\n/** Mint a fresh unique id from the active generator. */\nexport function freshId(): string {\n  return active.next();\n}\n\n/** The active session's siteId (tags Changes so the server can order them). */\nexport function currentSiteId(): string {\n  return active.siteId;\n}\n", "// Table-of-contents field instruction parsing + generation options. Pure and\r\n// layout-free, so import, export, and the backend route all share it.\r\n//\r\n// The OOXML `TOC` field instruction (e.g. ` TOC \\o \"1-3\" \\h \\z \\u `) governs WHICH\r\n// paragraphs become entries and some behaviors; the visual leader/right-tab live in\r\n// the TOC paragraph styles, not the instruction (see TocOptions).\r\n\r\nimport type { CharStyle, Document, ParaStyle, Paragraph } from \"./model/document\";\r\nimport { DEFAULT_CHAR_STYLE } from \"./model/defaults\";\r\nimport { bodyParagraphs, textOfRuns } from \"./model/text\";\r\nimport { sliceRuns } from \"./model/ops\";\r\nimport { freshId } from \"./ids\";\r\n\r\n/** Parsed `TOC` field switches. See ECMA-376 \u00A717.16.5.68. */\r\nexport interface TocSwitches {\r\n  /** \\o \"1-3\" \u2014 include built-in heading levels in this (inclusive) range. */\r\n  outlineRange?: { from: number; to: number };\r\n  /** \\u \u2014 also include paragraphs with a directly-applied outline level. */\r\n  useOutlineLevels: boolean;\r\n  /** \\t \"StyleName,level,\u2026\" \u2014 custom paragraph styles mapped to TOC levels. */\r\n  customStyles?: Record<string, number>;\r\n  /** \\h \u2014 emit each entry as a hyperlink to its heading. */\r\n  hyperlinks: boolean;\r\n  /** \\n \"1-3\" \u2014 omit page numbers for levels in this (inclusive) range. */\r\n  hidePageNumberRange?: { from: number; to: number };\r\n  /** \\p \"sep\" \u2014 text between the entry label and the page number (default tab). */\r\n  separator?: string;\r\n  /** \\z \u2014 hide tab/leader/page numbers in Web layout view (display-only). */\r\n  hideInWeb: boolean;\r\n}\r\n\r\nconst rangeOf = (s: string | undefined): { from: number; to: number } | undefined => {\r\n  if (!s) return undefined;\r\n  const m = s.match(/^(\\d+)\\s*-\\s*(\\d+)$/);\r\n  if (m) return { from: Number(m[1]), to: Number(m[2]) };\r\n  const n = s.match(/^\\d+$/) ? Number(s) : NaN;\r\n  return Number.isNaN(n) ? undefined : { from: n, to: n };\r\n};\r\n\r\n/** Parse a `TOC` field instruction string into its switches. */\r\nexport function parseTocInstruction(instr: string): TocSwitches {\r\n  const sw: TocSwitches = {\r\n    useOutlineLevels: /\\\\u\\b/.test(instr),\r\n    hyperlinks: /\\\\h\\b/.test(instr),\r\n    hideInWeb: /\\\\z\\b/.test(instr),\r\n  };\r\n  const oRange = rangeOf(instr.match(/\\\\o\\s+\"([^\"]+)\"/)?.[1]);\r\n  if (oRange) sw.outlineRange = oRange;\r\n  const nRange = rangeOf(instr.match(/\\\\n\\s+\"?([0-9-]+)\"?/)?.[1]);\r\n  if (nRange) sw.hidePageNumberRange = nRange;\r\n  const sep = instr.match(/\\\\p\\s+\"([^\"]*)\"/)?.[1];\r\n  if (sep !== undefined) sw.separator = sep;\r\n  const t = instr.match(/\\\\t\\s+\"([^\"]+)\"/)?.[1];\r\n  if (t) {\r\n    const pairs = t.split(\",\");\r\n    const map: Record<string, number> = {};\r\n    for (let i = 0; i + 1 < pairs.length; i += 2) {\r\n      const name = pairs[i]!.trim();\r\n      const lvl = Number(pairs[i + 1]!.trim());\r\n      if (name && lvl >= 1) map[name] = lvl;\r\n    }\r\n    if (Object.keys(map).length > 0) sw.customStyles = map;\r\n  }\r\n  return sw;\r\n}\r\n\r\n/** Synthesize a `TOC` field instruction from switches (inverse of\r\n *  parseTocInstruction; round-trips the switches it models). Switch order follows\r\n *  Word's own emit so a re-parse is stable. */\r\nexport function buildTocInstruction(sw: TocSwitches): string {\r\n  const parts: string[] = [\"TOC\"];\r\n  if (sw.outlineRange) parts.push(`\\\\o \"${sw.outlineRange.from}-${sw.outlineRange.to}\"`);\r\n  if (sw.useOutlineLevels) parts.push(\"\\\\u\");\r\n  if (sw.customStyles && Object.keys(sw.customStyles).length > 0) {\r\n    const t = Object.entries(sw.customStyles).map(([name, lvl]) => `${name},${lvl}`).join(\",\");\r\n    parts.push(`\\\\t \"${t}\"`);\r\n  }\r\n  if (sw.hyperlinks) parts.push(\"\\\\h\");\r\n  if (sw.hidePageNumberRange) parts.push(`\\\\n \"${sw.hidePageNumberRange.from}-${sw.hidePageNumberRange.to}\"`);\r\n  if (sw.separator !== undefined) parts.push(`\\\\p \"${sw.separator}\"`);\r\n  if (sw.hideInWeb) parts.push(\"\\\\z\");\r\n  return ` ${parts.join(\" \")} `;\r\n}\r\n\r\n/** Is `level` covered by an inclusive range (undefined range = no). */\r\nexport const inRange = (r: { from: number; to: number } | undefined, level: number): boolean =>\r\n  !!r && level >= r.from && level <= r.to;\r\n\r\n// ---------------------------------------------------------------------------\r\n// Heading detection (shared by the editor's TOC generation and the headless\r\n// route) \u2014 robust to opaque style ids: tries the effective outline level, then\r\n// the resolved style NAME (\"Heading 1\"), then a `namedStyle` like \"heading1\",\r\n// then \\t custom-style mappings.\r\n\r\n/** The friendly name of a style id, following basedOn (for opaque numeric ids). */\r\nfunction styleNameOf(doc: Document, id: string | undefined): string | undefined {\r\n  if (!id || !doc.stylesheet) return undefined;\r\n  const byId = new Map(doc.stylesheet.styles.map((s) => [s.id, s]));\r\n  let cur = byId.get(id);\r\n  const seen = new Set<string>();\r\n  while (cur && !seen.has(cur.id)) {\r\n    if (cur.name && /(?:^|\\s)heading\\s*\\d/i.test(cur.name)) return cur.name;\r\n    seen.add(cur.id);\r\n    cur = cur.basedOn ? byId.get(cur.basedOn) : undefined;\r\n  }\r\n  return byId.get(id)?.name;\r\n}\r\n\r\n/** TOC level (1-based) for a paragraph, or null if it's not a heading. */\r\nexport function tocHeadingLevel(p: Paragraph, doc: Document, sw?: TocSwitches): number | null {\r\n  const named = p.style.namedStyle;\r\n  // \\t custom styles (match by opaque id or by friendly name).\r\n  if (sw?.customStyles && named) {\r\n    const lv = sw.customStyles[named] ?? sw.customStyles[styleNameOf(doc, named) ?? \"\"];\r\n    if (lv) return lv;\r\n  }\r\n  if (p.style.outlineLevel !== undefined) return p.style.outlineLevel + 1;\r\n  const direct = named?.match(/^heading\\s*(\\d)$/i);\r\n  if (direct) return Number(direct[1]);\r\n  const m = styleNameOf(doc, named)?.match(/(?:^|\\s)heading\\s*(\\d)/i);\r\n  return m ? Number(m[1]) : null;\r\n}\r\n\r\n/** All TOC-eligible headings in document order (body + table cells), honoring the\r\n *  switches' `\\o` range (when present) and `maxLevel`. */\r\nexport function detectTocHeadings(\r\n  doc: Document,\r\n  sw?: TocSwitches,\r\n  maxLevel = 3,\r\n): { block: Paragraph; level: number }[] {\r\n  const cap = sw?.outlineRange?.to ?? maxLevel;\r\n  const out: { block: Paragraph; level: number }[] = [];\r\n  for (const p of bodyParagraphs(doc)) {\r\n    const level = tocHeadingLevel(p, doc, sw);\r\n    if (level === null || level < 1 || level > cap) continue;\r\n    if (sw?.outlineRange && (level < sw.outlineRange.from || level > sw.outlineRange.to)) continue;\r\n    out.push({ block: p, level });\r\n  }\r\n  return out;\r\n}\r\n\r\n// ---------------------------------------------------------------------------\r\n// Imported-TOC unification: an imported TOC field flattens to plain paragraphs\r\n// (label + \"#anchor\" hyperlink + cached \"\\t<number>\" text). To round-trip it as a\r\n// LIVE field on export, mark those paragraphs as tocEntry and STRIP the cached\r\n// number text \u2014 so the number becomes layout-driven (paint decoration), exactly\r\n// like an editor-created TOC, and export wraps it in a real TOC/PAGEREF field.\r\n\r\n/** Mark a document's imported TOC entries as tocEntry and strip their cached page\r\n *  numbers. Gated by the caller (only when a TOC field exists). Returns the count.\r\n *  An entry is a body paragraph with a \"#anchor\" link resolving to a bookmarked\r\n *  block plus a trailing \"\\t<number>\"; level is inferred from its left indent. */\r\nexport function markImportedTocEntries(doc: Document, indentStepPx = 20): number {\r\n  if (!doc.bookmarks) return 0;\r\n  const contentWidthPx = doc.section.pageWidthPx - doc.section.marginPx.left - doc.section.marginPx.right;\r\n  let count = 0;\r\n  for (const b of doc.blocks) {\r\n    if (b.kind !== \"paragraph\" || b.style.tocEntry) continue;\r\n    const anchor = b.runs.find((r) => r.style.link?.startsWith(\"#\"))?.style.link?.slice(1);\r\n    if (!anchor) continue;\r\n    const targetId = doc.bookmarks[anchor]?.start.blockId;\r\n    if (!targetId) continue;\r\n    const full = textOfRuns(b.runs);\r\n    const m = full.match(/\\t\\d+\\s*$/); // trailing tab + page number\r\n    if (!m) continue;\r\n    b.runs = sliceRuns(b.runs, 0, full.length - m[0].length); // drop \"\\t<number>\"\r\n    if (b.runs.length === 0) b.runs = [{ text: \"\", style: { ...TOC_BASE_CHAR } }];\r\n    const level = Math.min(9, Math.max(1, Math.round((b.style.indentLeftPx || 0) / indentStepPx) + 1));\r\n    b.style.tocEntry = { targetId, level };\r\n    // Right-aligned dot leader so the painted/exported number aligns (if none set).\r\n    if (!b.style.tabStops?.length && contentWidthPx > 0) {\r\n      b.style.tabStops = [{ posPx: contentWidthPx, align: \"right\", leader: \"dot\" }];\r\n    }\r\n    b.revision++;\r\n    count++;\r\n  }\r\n  return count;\r\n}\r\n\r\n// ---------------------------------------------------------------------------\r\n// Generation options \u2014 everything that used to be hardcoded in\r\n// buildTocParagraphs, exposed so the editor AND the backend route can pass it.\r\n\r\nexport interface TocLevelStyle {\r\n  char?: Partial<CharStyle>;\r\n  para?: Partial<ParaStyle>;\r\n}\r\n\r\n/** TOC entries default to the body font/color, one notch smaller. */\r\nconst TOC_BASE_CHAR: CharStyle = { ...DEFAULT_CHAR_STYLE, fontSizePx: 13 };\r\n\r\n/** Per-level left-indent step (px) when none is supplied via TocOptions. */\r\nconst TOC_INDENT_STEP_PX = 20;\r\n\r\n/** Resolve the char + paragraph style for a TOC entry at `level`. Precedence:\r\n *  built-in defaults < the document's own TOC style (`inherit`, from its TOC field\r\n *  paragraph) < caller `TocOptions`. When `inherit` is given we DON'T impose the\r\n *  built-in level-1 bold / size bumps \u2014 we respect the document's look (matching the\r\n *  source Word doc); without it, the editor's default look is used. The para carries\r\n *  the right-aligned leader tab stop (callers add `tocEntry`). */\r\nexport function tocEntryStyle(\r\n  opts: TocOptions,\r\n  level: number,\r\n  contentWidthPx: number,\r\n  inherit?: { char?: CharStyle | undefined; para?: ParaStyle | undefined },\r\n): { char: CharStyle; para: ParaStyle } {\r\n  const indentStep = opts.indentStepPx ?? TOC_INDENT_STEP_PX;\r\n  const leader = opts.leader ?? \"dot\";\r\n  // Shared paragraph base for every entry, before indent + per-level overrides.\r\n  const paraBase = { align: \"left\", lineHeight: 1.5, spaceBeforePx: 0, spaceAfterPx: 2, indentFirstLinePx: 0 } as const;\r\n  let char: CharStyle;\r\n  let para: ParaStyle;\r\n  if (inherit && (inherit.char || inherit.para)) {\r\n    char = { ...TOC_BASE_CHAR, ...inherit.char, ...opts.baseChar, ...opts.levels?.[level]?.char };\r\n    const baseIndent = inherit.para?.indentLeftPx ?? 0;\r\n    para = {\r\n      ...paraBase,\r\n      ...inherit.para,\r\n      indentLeftPx: baseIndent + (level - 1) * indentStep,\r\n      ...opts.levels?.[level]?.para,\r\n    };\r\n  } else {\r\n    const base = { ...TOC_BASE_CHAR, ...opts.baseChar };\r\n    char = { ...base, fontSizePx: level === 1 ? 14 : 13, bold: level === 1, ...opts.levels?.[level]?.char };\r\n    para = {\r\n      ...paraBase,\r\n      indentLeftPx: (level - 1) * indentStep, ...opts.levels?.[level]?.para,\r\n    };\r\n  }\r\n  if (leader !== \"none\" && contentWidthPx > 0) para.tabStops = [{ posPx: contentWidthPx, align: \"right\", leader }];\r\n  else delete para.tabStops; // leader:\"none\" overrides any inherited leader tab\r\n  return { char, para };\r\n}\r\n\r\n/** The TOC title paragraph's resolved styles, or null when titles are disabled. */\r\nexport function tocTitleStyle(opts: TocOptions): { text: string; char: CharStyle; para: ParaStyle } | null {\r\n  if (opts.title === null) return null;\r\n  const t = opts.title ?? {};\r\n  const base = { ...TOC_BASE_CHAR, ...opts.baseChar };\r\n  return {\r\n    text: t.text ?? \"Table of Contents\",\r\n    char: { ...base, fontSizePx: 20, bold: true, ...t.char },\r\n    para: {\r\n      align: \"left\", lineHeight: 1.4, spaceBeforePx: 8, spaceAfterPx: 12,\r\n      indentFirstLinePx: 0, indentLeftPx: 0, namedStyle: t.namedStyle ?? \"tocTitle\", ...t.para,\r\n    },\r\n  };\r\n}\r\n\r\nexport interface TocOptions {\r\n  /** TOC title paragraph; null/omit to skip a title. */\r\n  title?: { text?: string; char?: Partial<CharStyle>; para?: Partial<ParaStyle>; namedStyle?: string } | null;\r\n  /** Base char style applied to every entry before per-level overrides. */\r\n  baseChar?: Partial<CharStyle>;\r\n  /** Per-level (1-based) style overrides. */\r\n  levels?: Record<number, TocLevelStyle>;\r\n  /** Deepest heading level to include (default 3). */\r\n  maxLevel?: number;\r\n  /** Per-level left indent step in px (default 20). */\r\n  indentStepPx?: number;\r\n  /** Dot-leader between label and page number (default \"dot\"). */\r\n  leader?: \"dot\" | \"dash\" | \"underscore\" | \"none\";\r\n  /** Show page numbers (default true). */\r\n  includePageNumbers?: boolean;\r\n  /** Emit entries as hyperlinks (default true). */\r\n  hyperlink?: boolean;\r\n}\r\n\r\n// ---------------------------------------------------------------------------\r\n// TOC generation \u2014 entries are REAL paragraphs tagged with `tocEntry` (so they\r\n// lay out, paint, hit-test, and export as a live field for free). Page numbers\r\n// are paint-only: the layout engine resolves each entry's number per relayout,\r\n// so they never go stale. Shared by the editor (insertTocCmd) and the headless\r\n// PDF/DOCX render path.\r\n\r\nconst TOC_LEVELS = 3;\r\n\r\n/** Build TOC paragraphs (optional title + one entry per heading) from a document's\r\n *  headings. Every hardcoded look is an overridable `TocOptions` default. The page\r\n *  number is paint-only (layout post-pass); a right-aligned dot-leader tab stop\r\n *  right-aligns it. Mutates nothing. */\r\nexport function buildTocParagraphs(doc: Document, opts: TocOptions = {}): Paragraph[] {\r\n  // Honor the document's own TOC field switches (\\o level range, \\t custom styles, \u2026)\r\n  // so a C#-emitted ` TOC \\o \"1-5\" ` lists all five levels, not the default three.\r\n  const sw = doc.tocInstruction ? parseTocInstruction(doc.tocInstruction) : undefined;\r\n  const maxLevel = opts.maxLevel ?? sw?.outlineRange?.to ?? TOC_LEVELS;\r\n  const contentWidthPx = doc.section.pageWidthPx - doc.section.marginPx.left - doc.section.marginPx.right;\r\n\r\n  // Inherit the document's own TOC styling from the TOC field's paragraph (its pStyle,\r\n  // e.g. \"TOC 1\", resolved on import \u2192 the doc's intended font/size/indent). Absent for\r\n  // an editor-inserted TOC in a doc with no TOC field \u2192 the built-in default look.\r\n  const anchor = doc.tocAnchorBlockId\r\n    ? doc.blocks.find((b): b is Paragraph => b.kind === \"paragraph\" && b.id === doc.tocAnchorBlockId)\r\n    : undefined;\r\n  const inherit = anchor ? { char: anchor.runs[0]?.style, para: anchor.style } : undefined;\r\n\r\n  const out: Paragraph[] = [];\r\n\r\n  // Title: an explicit opts.title wins; otherwise add the default title only when we're\r\n  // NOT filling an existing TOC field (a doc with a TOC field usually has its own title\r\n  // heading already, so a generated one would duplicate it).\r\n  const wantTitle = opts.title !== undefined ? opts.title !== null : anchor === undefined;\r\n  if (wantTitle) {\r\n    const title = tocTitleStyle(opts);\r\n    if (title) {\r\n      out.push({\r\n        kind: \"paragraph\", id: freshId(), revision: 0,\r\n        runs: [{ text: title.text, style: title.char }],\r\n        style: title.para,\r\n      });\r\n    }\r\n  }\r\n\r\n  // Scan body AND table-cell paragraphs so headings inside tables are listed.\r\n  for (const { block, level } of detectTocHeadings(doc, sw, maxLevel)) {\r\n    const text = textOfRuns(block.runs).replace(/\\v/g, \" \").trim();\r\n    if (text.length === 0) continue;\r\n    const { char, para } = tocEntryStyle(opts, level, contentWidthPx, inherit);\r\n    out.push({\r\n      kind: \"paragraph\", id: freshId(), revision: 0,\r\n      runs: [{ text, style: char }],\r\n      style: { ...para, tocEntry: { targetId: block.id, level } },\r\n    });\r\n  }\r\n  return out;\r\n}\r\n\r\n/** Fill an EMPTY TOC field: build entries from the document's headings and splice\r\n *  them at the captured field location (`doc.tocAnchorBlockId`). Page numbers stay\r\n *  paint-only \u2014 the layout engine resolves them on render. Returns a NEW doc (input\r\n *  not mutated).\r\n *\r\n *  If the TOC field ALREADY has entries (imported and marked as `tocEntry`), they are\r\n *  PRESERVED untouched \u2014 they carry the source document's own styling and their page\r\n *  numbers are recomputed by layout, so rebuilding from headings (with our defaults)\r\n *  would only throw the author's TOC away. No headings / nowhere to anchor \u2192 unchanged. */\r\nexport function generateTocIntoDoc(\r\n  doc: Document,\r\n  opts: TocOptions = {},\r\n): { doc: Document; generated: number; headings: number } {\r\n  // Already populated (e.g. a Word/C#-rendered TOC) \u2192 keep it as-is.\r\n  if (doc.blocks.some((b) => b.kind === \"paragraph\" && b.style.tocEntry)) {\r\n    return { doc, generated: 0, headings: 0 };\r\n  }\r\n  if (doc.tocAnchorBlockId === undefined) return { doc, generated: 0, headings: 0 };\r\n  const at = doc.blocks.findIndex((b) => b.id === doc.tocAnchorBlockId);\r\n  if (at < 0) return { doc, generated: 0, headings: 0 };\r\n\r\n  const fresh = buildTocParagraphs(doc, opts);\r\n  const headings = fresh.reduce((n, p) => n + (p.style.tocEntry ? 1 : 0), 0);\r\n  if (headings === 0) return { doc, generated: 0, headings: 0 };\r\n\r\n  const blocks = [...doc.blocks];\r\n  blocks.splice(at, 1, ...fresh); // replace the empty TOC field paragraph\r\n  return { doc: { ...doc, blocks }, generated: headings, headings };\r\n}\r\n", "// Named styles (Word's style gallery). The editor model keeps runs CONCRETE \u2014\n// styles here are templates + references, not a live cascade at render time:\n//   - applying a style patches exactly the fields the style defines (direct\n//     formatting on other fields survives, like Word),\n//   - modifying a style re-patches every paragraph that references it,\n//   - resolution walks the basedOn chain (editor-simple override semantics;\n//     OOXML XOR-toggle fidelity lives in import/docx/styles.ts, which resolves\n//     to concrete values at import time and preserves the styleId reference \u2014\n//     the two systems share the same id space).\n\nimport type { CharStyle, Document, ParaStyle, Paragraph } from \"./document\";\nimport type { EditorTypography } from \"./defaults\";\nimport { paragraphsOf } from \"./text\";\n\nexport type NamedStyleType = \"paragraph\" | \"character\";\n\nexport interface NamedStyle {\n  id: string; // shares the docx styleId space (\"Normal\", \"Heading1\", ...)\n  name: string; // display name\n  /** Paragraph vs character style (Word's two text-level style kinds). Optional\n   *  for back-compat: legacy stylesheets and defaultStylesheet() omit it and read\n   *  as \"paragraph\" via styleType(). Character styles store only `char` (empty\n   *  `para`) and apply to runs, not paragraphs. */\n  type?: NamedStyleType;\n  basedOn?: string;\n  char: Partial<CharStyle>;\n  para: Partial<ParaStyle>;\n}\n\nexport interface Stylesheet {\n  styles: NamedStyle[];\n  defaultStyleId: string;\n}\n\n/** A style's kind, defaulting untyped (legacy) styles to \"paragraph\". Read this\n *  rather than `.type` directly so old documents keep working. */\nexport function styleType(s: NamedStyle): NamedStyleType {\n  return s.type ?? \"paragraph\";\n}\n\nexport function styleById(sheet: Stylesheet, id: string): NamedStyle | undefined {\n  return sheet.styles.find((s) => s.id === id);\n}\n\n/** Resolved templates: basedOn chain root\u2192leaf, defined fields override. */\nexport function resolveStyle(\n  sheet: Stylesheet,\n  id: string,\n): { char: Partial<CharStyle>; para: Partial<ParaStyle> } {\n  const chain: NamedStyle[] = [];\n  const seen = new Set<string>();\n  for (let cur = styleById(sheet, id); cur && !seen.has(cur.id); cur = cur.basedOn ? styleById(sheet, cur.basedOn) : undefined) {\n    seen.add(cur.id);\n    chain.unshift(cur);\n  }\n  const char: Partial<CharStyle> = {};\n  const para: Partial<ParaStyle> = {};\n  for (const s of chain) {\n    Object.assign(char, definedOnly(s.char));\n    Object.assign(para, definedOnly(s.para));\n  }\n  return { char, para };\n}\n\n/** Resolved character template only: basedOn chain root\u2192leaf, defined `char`\n *  fields override. Character styles have no `para`, so this is the run-level\n *  equivalent of resolveStyle for type===\"character\" styles. */\nexport function resolveCharStyle(sheet: Stylesheet, id: string): Partial<CharStyle> {\n  const chain: NamedStyle[] = [];\n  const seen = new Set<string>();\n  for (let cur = styleById(sheet, id); cur && !seen.has(cur.id); cur = cur.basedOn ? styleById(sheet, cur.basedOn) : undefined) {\n    seen.add(cur.id);\n    chain.unshift(cur);\n  }\n  const char: Partial<CharStyle> = {};\n  for (const s of chain) Object.assign(char, definedOnly(s.char));\n  return char;\n}\n\n/** Every style id that (transitively) lists `id` as its basedOn ancestor. Used\n *  to keep a style out of its own descendants' \"Based on\" pickers. */\nexport function descendantsOf(sheet: Stylesheet, id: string): Set<string> {\n  const out = new Set<string>();\n  let grew = true;\n  while (grew) {\n    grew = false;\n    for (const s of sheet.styles) {\n      if (out.has(s.id)) continue;\n      if (s.basedOn !== undefined && (s.basedOn === id || out.has(s.basedOn))) {\n        out.add(s.id);\n        grew = true;\n      }\n    }\n  }\n  return out;\n}\n\n/** Would setting `styleId`'s basedOn to `newBasedOn` create a cycle? True if\n *  newBasedOn is the style itself or one of its descendants. A backstop for the\n *  UI, which already excludes these from the picker. */\nexport function wouldCycle(sheet: Stylesheet, styleId: string, newBasedOn: string | undefined): boolean {\n  if (!newBasedOn) return false;\n  if (newBasedOn === styleId) return true;\n  return descendantsOf(sheet, styleId).has(newBasedOn);\n}\n\n/** A canonical signature of a style's FORMATTING (everything but id + name):\n *  type, basedOn, and its defined char/para deltas with keys sorted \u2014 so two\n *  styles that differ only by name (or id) produce the same string. */\nfunction styleSignature(s: NamedStyle): string {\n  const norm = (o: object): [string, unknown][] =>\n    Object.entries(definedOnly(o)).sort(([a], [b]) => (a < b ? -1 : a > b ? 1 : 0));\n  return JSON.stringify([styleType(s), s.basedOn ?? \"\", norm(s.char), norm(s.para)]);\n}\n\nexport interface StyleMergeResult {\n  sheet: Stylesheet;\n  /** mergedId \u2192 survivingId, for every style that was collapsed away. Empty when\n   *  there were no duplicates. */\n  remap: Map<string, string>;\n}\n\n/** Collapse named styles that are identical except for their name/id: each group\n *  of same-signature styles keeps ONE survivor (the default style if the group\n *  contains it, otherwise the first in document order) and the rest are dropped,\n *  their ids remapped to the survivor. basedOn pointers (and defaultStyleId) are\n *  rewritten through the remap. Callers remap content references (paragraph\n *  namedStyle / run charStyleId) using `remap`. */\nexport function mergeDuplicateNamedStyles(sheet: Stylesheet): StyleMergeResult {\n  const remap = new Map<string, string>();\n  const survivorBySig = new Map<string, string>();\n  for (const s of sheet.styles) {\n    const sig = styleSignature(s);\n    const survivor = survivorBySig.get(sig);\n    if (survivor === undefined) {\n      survivorBySig.set(sig, s.id);\n    } else if (s.id === sheet.defaultStyleId) {\n      // The default style must survive \u2014 promote it and fold the prior survivor.\n      survivorBySig.set(sig, s.id);\n      remap.set(survivor, s.id);\n      for (const [k, v] of remap) if (v === survivor) remap.set(k, s.id);\n    } else {\n      remap.set(s.id, survivor);\n    }\n  }\n  if (remap.size === 0) return { sheet, remap };\n\n  const resolveId = (id: string): string => remap.get(id) ?? id;\n  const styles: NamedStyle[] = [];\n  for (const s of sheet.styles) {\n    if (remap.has(s.id)) continue; // collapsed away\n    const next: NamedStyle = { ...s };\n    if (next.basedOn !== undefined) {\n      const rebased = resolveId(next.basedOn);\n      if (rebased === next.id) delete next.basedOn; // self-reference after merge\n      else next.basedOn = rebased;\n    }\n    styles.push(next);\n  }\n  return { sheet: { styles, defaultStyleId: resolveId(sheet.defaultStyleId) }, remap };\n}\n\nfunction definedOnly<T extends object>(o: T): Partial<T> {\n  const out: Partial<T> = {};\n  for (const [k, v] of Object.entries(o)) {\n    if (v !== undefined) (out as Record<string, unknown>)[k] = v;\n  }\n  return out;\n}\n\n/** Every editable paragraph referencing a style \u2014 paragraphsOf already covers\n *  body, table cells, and both margin bands in document order. */\nexport function paragraphsWithStyle(doc: Document, styleId: string): Paragraph[] {\n  return paragraphsOf(doc).filter((p) => p.style.namedStyle === styleId);\n}\n\n/** The built-in starter stylesheet (Normal + Title/Subtitle/Heading/Quote/Code).\n *  `t` overrides only the LIBRARY defaults \u2014 the body (Normal) font/size/color +\n *  line height, and the heading font family. It is used for NEW/blank documents\n *  and as the fallback when a document carries no stylesheet of its own; a loaded\n *  .docx keeps its own w:docDefaults / Normal style (the importer bakes those in).\n *  Zero-arg reproduces the historical default byte-for-byte. */\nexport function makeDefaultStylesheet(t: EditorTypography = {}): Stylesheet {\n  const fontFamily = t.fontFamily ?? \"Georgia, serif\";\n  const fontSizePx = t.fontSizePx ?? 16;\n  const color = t.color ?? \"#202124\";\n  const headingFont = t.headingFontFamily ?? \"Arial, sans-serif\";\n  const base: Partial<ParaStyle> = { lineHeight: t.lineHeight ?? 1.5, spaceBeforePx: 0, spaceAfterPx: 12 };\n  return {\n    defaultStyleId: \"Normal\",\n    styles: [\n      {\n        id: \"Normal\",\n        name: \"Normal\",\n        char: { fontFamily, fontSizePx, bold: false, italic: false, color },\n        para: { ...base, align: \"left\", indentFirstLinePx: 0 },\n      },\n      {\n        id: \"Title\",\n        name: \"Title\",\n        basedOn: \"Normal\",\n        char: { fontFamily: headingFont, fontSizePx: 32, bold: true, color: \"#1a1a2e\" },\n        para: { align: \"center\", spaceAfterPx: 4 },\n      },\n      {\n        id: \"Subtitle\",\n        name: \"Subtitle\",\n        basedOn: \"Normal\",\n        char: { italic: true, color: \"#5f6368\" },\n        para: { align: \"center\", spaceAfterPx: 28 },\n      },\n      {\n        id: \"Heading1\",\n        name: \"Heading 1\",\n        basedOn: \"Normal\",\n        char: { fontFamily: headingFont, fontSizePx: 24, bold: true, color: \"#1a1a2e\" },\n        para: { spaceBeforePx: 18, spaceAfterPx: 8, keepWithNext: true },\n      },\n      {\n        id: \"Heading2\",\n        name: \"Heading 2\",\n        basedOn: \"Heading1\",\n        char: { fontSizePx: 19 },\n        para: { spaceBeforePx: 14, spaceAfterPx: 6 },\n      },\n      {\n        id: \"Quote\",\n        name: \"Quote\",\n        basedOn: \"Normal\",\n        char: { italic: true, color: \"#5f6368\" },\n        para: { indentLeftPx: 36, spaceBeforePx: 8, spaceAfterPx: 8 },\n      },\n      {\n        id: \"Code\",\n        name: \"Code\",\n        basedOn: \"Normal\",\n        char: { fontFamily: \"Consolas, monospace\", fontSizePx: 14, color: \"#0b57d0\" },\n        para: { lineHeight: 1.35 },\n      },\n    ],\n  };\n}\n\n/** The built-in starter stylesheet with no overrides. */\nexport function defaultStylesheet(): Stylesheet {\n  return makeDefaultStylesheet();\n}\n", "// Layer 1 (math): the canonical internal form for equations \u2014 a Presentation\r\n// MathML abstract syntax tree. Pure data (JSON-serializable, no DOM/canvas), so\r\n// it lives beside the rest of the document model and round-trips through\r\n// persistence for free.\r\n//\r\n// WHY MathML and not OMML: the editor, caret movement, and the typesetter all\r\n// operate on this structured tree. `.docx` stores math as OMML (the `m:`\r\n// namespace), so the import/export pipelines convert OMML <-> this AST at the\r\n// edges (see frontend/src/mathml). MathML strings (paste, the equation editor)\r\n// also parse to / serialize from this same tree.\r\n//\r\n// Design notes for the editor:\r\n//  - Script kinds (sup/sub/subsup) are ONE node (`script`) with optional sub/sup.\r\n//  - Limit kinds (under/over/underover) are ONE node (`limit`).\r\n//  - Radical kinds (sqrt/root) are ONE node (`radical`) with optional index.\r\n//    Unifying these keeps the visual editor generic: it edits SLOTS, not a\r\n//    per-element zoo. `mathSlots`/`mapMathSlots` expose those slots uniformly.\r\n//  - An empty `row` (no children) is a PLACEHOLDER SLOT \u2014 what the editor shows\r\n//    as a dotted box you can tab into and type.\r\n\r\n/** MathML `mathvariant` \u2014 selects an alphanumeric style (blackboard, fraktur,\r\n *  script, \u2026). Maps to/from OMML run style (`m:sty`) for the common cases. */\r\nexport type MathVariant =\r\n  | \"normal\"\r\n  | \"bold\"\r\n  | \"italic\"\r\n  | \"bold-italic\"\r\n  | \"double-struck\"\r\n  | \"fraktur\"\r\n  | \"bold-fraktur\"\r\n  | \"script\"\r\n  | \"bold-script\"\r\n  | \"sans-serif\"\r\n  | \"bold-sans-serif\"\r\n  | \"sans-serif-italic\"\r\n  | \"sans-serif-bold-italic\"\r\n  | \"monospace\";\r\n\r\n/** A horizontal list of sub-expressions (MathML `mrow`; also the canonical\r\n *  wrapper for `math`/`mstyle`). An EMPTY row is an editable placeholder slot. */\r\nexport interface MathRow {\r\n  type: \"row\";\r\n  children: MathNode[];\r\n}\r\n\r\n/** Identifier \u2014 a variable or function name (MathML `mi`). Default rendering is\r\n *  italic for single letters; `variant` overrides (e.g. blackboard-bold \u211D). */\r\nexport interface MathIdent {\r\n  type: \"ident\";\r\n  text: string;\r\n  variant?: MathVariant;\r\n}\r\n\r\n/** Number literal (MathML `mn`). Rendered upright by default; `variant` overrides\r\n *  the alphanumeric style (e.g. blackboard-bold `\uD835\uDFD9`, monospace digits). */\r\nexport interface MathNumber {\r\n  type: \"number\";\r\n  text: string;\r\n  variant?: MathVariant;\r\n}\r\n\r\n/** Operator, relation, fence, or separator (MathML `mo`). `stretchy` lets a\r\n *  delimiter/arrow grow to its context; `form` disambiguates spacing class. */\r\nexport interface MathOperator {\r\n  type: \"op\";\r\n  text: string;\r\n  stretchy?: boolean;\r\n  form?: \"prefix\" | \"infix\" | \"postfix\";\r\n}\r\n\r\n/** Literal text run inside math (MathML `mtext`) \u2014 upright, normal spacing. */\r\nexport interface MathText {\r\n  type: \"text\";\r\n  text: string;\r\n}\r\n\r\n/** Explicit spacing (MathML `mspace`), width in ems. */\r\nexport interface MathSpace {\r\n  type: \"space\";\r\n  widthEm?: number;\r\n}\r\n\r\n/** Fraction (MathML `mfrac`). `bevelled` = diagonal bar; `thickness: \"0\"` = no\r\n *  bar (binomial coefficients `\\binom`). */\r\nexport interface MathFrac {\r\n  type: \"frac\";\r\n  num: MathNode;\r\n  den: MathNode;\r\n  bevelled?: boolean;\r\n  thickness?: \"0\" | \"normal\";\r\n}\r\n\r\n/** Sub/superscript (MathML `msub`/`msup`/`msubsup`), unified: presence of\r\n *  `sub`/`sup` selects the concrete element. At least one is set. */\r\nexport interface MathScript {\r\n  type: \"script\";\r\n  base: MathNode;\r\n  sub?: MathNode;\r\n  sup?: MathNode;\r\n}\r\n\r\n/** Radical (MathML `msqrt`/`mroot`). `index` present = nth root. */\r\nexport interface MathRadical {\r\n  type: \"radical\";\r\n  radicand: MathNode;\r\n  index?: MathNode;\r\n}\r\n\r\n/** Fenced expression \u2014 delimiters around content (MathML `mfenced`, or OMML\r\n *  `m:d`). Empty `open`/`close` strings mean \"no delimiter on that side\". */\r\nexport interface MathFenced {\r\n  type: \"fenced\";\r\n  open: string;\r\n  close: string;\r\n  /** Separator chars cycled between children when the content is a row. */\r\n  separators?: string;\r\n  child: MathNode;\r\n}\r\n\r\n/** Under/over scripts (MathML `munder`/`mover`/`munderover`), unified \u2014 limits,\r\n *  overbars, hats, underbraces. `accent` keeps the OVER script tight to the base\r\n *  (MathML `accent`); `accentUnder` does the same for the UNDER script (MathML\r\n *  `accentunder`). The two are independent so an over-accent (hat) and an\r\n *  under-accent (underbrace/underbar) never collapse to the same encoding. */\r\nexport interface MathLimit {\r\n  type: \"limit\";\r\n  base: MathNode;\r\n  under?: MathNode;\r\n  over?: MathNode;\r\n  accent?: boolean;\r\n  accentUnder?: boolean;\r\n}\r\n\r\n/** N-ary operator with limits (OMML `m:nary`: \u2211 \u220F \u222B \u2026). MathML has no single\r\n *  element for this; it serializes to a scripted operator followed by the body.\r\n *  `hideOp` renders just the scripted limits with no operator glyph. */\r\nexport interface MathNary {\r\n  type: \"nary\";\r\n  op: string;\r\n  sub?: MathNode;\r\n  sup?: MathNode;\r\n  body: MathNode;\r\n  hideOp?: boolean;\r\n}\r\n\r\n/** Matrix / array / cases (MathML `mtable`, OMML `m:m`). Row-major. */\r\nexport interface MathMatrix {\r\n  type: \"matrix\";\r\n  rows: MathNode[][];\r\n  colAlign?: (\"left\" | \"center\" | \"right\")[];\r\n}\r\n\r\n/** Phantom \u2014 occupies space but paints nothing (MathML `mphantom`). */\r\nexport interface MathPhantom {\r\n  type: \"phantom\";\r\n  child: MathNode;\r\n}\r\n\r\n/** Integrity net for constructs outside the supported set: the original source\r\n *  is kept verbatim so export re-emits it losslessly and nothing is silently\r\n *  dropped. The typesetter renders a visible placeholder. Reaching this in\r\n *  practice is a coverage bug to fix, not an accepted fallback. */\r\nexport interface MathUnknown {\r\n  type: \"unknown\";\r\n  omml?: string;\r\n  mathml?: string;\r\n}\r\n\r\nexport type MathNode =\r\n  | MathRow\r\n  | MathIdent\r\n  | MathNumber\r\n  | MathOperator\r\n  | MathText\r\n  | MathSpace\r\n  | MathFrac\r\n  | MathScript\r\n  | MathRadical\r\n  | MathFenced\r\n  | MathLimit\r\n  | MathNary\r\n  | MathMatrix\r\n  | MathPhantom\r\n  | MathUnknown;\r\n\r\n/** A whole equation as stored in the document: the root is always a `row`.\r\n *  `display` = block (own line, centered); inline = sits in a text line. */\r\nexport interface MathEquation {\r\n  root: MathRow;\r\n  display: boolean;\r\n}\r\n\r\n// \u2500\u2500 Constructors / guards \u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\r\n\r\n/** An empty row \u2014 the editor's placeholder slot. */\r\nexport function emptyMathRow(): MathRow {\r\n  return { type: \"row\", children: [] };\r\n}\r\n\r\n/** A row is a placeholder when it has no children (renders as a dotted box). */\r\nexport function isEmptyMathRow(n: MathNode): boolean {\r\n  return n.type === \"row\" && n.children.length === 0;\r\n}\r\n\r\n/** Wrap a node in a row unless it already is one (normalizes slot contents). */\r\nexport function asMathRow(n: MathNode): MathRow {\r\n  return n.type === \"row\" ? n : { type: \"row\", children: [n] };\r\n}\r\n\r\n// \u2500\u2500 Generic slot traversal (powers the visual editor + the typesetter) \u2500\u2500\u2500\u2500\u2500\u2500\u2500\r\n\r\n/** Ordered child SLOTS of a node \u2014 the editable sub-expressions, in document\r\n *  order. Leaf nodes (ident/number/op/text/space/unknown) have none. Used by\r\n *  the editor for caret navigation and by converters/typesetter to recurse\r\n *  without a per-type switch at every call site. */\r\nexport function mathSlots(n: MathNode): MathNode[] {\r\n  switch (n.type) {\r\n    case \"row\":\r\n      return n.children;\r\n    case \"frac\":\r\n      return [n.num, n.den];\r\n    case \"script\":\r\n      return [n.base, ...(n.sub ? [n.sub] : []), ...(n.sup ? [n.sup] : [])];\r\n    case \"radical\":\r\n      return [n.radicand, ...(n.index ? [n.index] : [])];\r\n    case \"fenced\":\r\n      return [n.child];\r\n    case \"limit\":\r\n      return [n.base, ...(n.under ? [n.under] : []), ...(n.over ? [n.over] : [])];\r\n    case \"nary\":\r\n      return [...(n.sub ? [n.sub] : []), ...(n.sup ? [n.sup] : []), n.body];\r\n    case \"matrix\":\r\n      return n.rows.flat();\r\n    case \"phantom\":\r\n      return [n.child];\r\n    default:\r\n      return [];\r\n  }\r\n}\r\n\r\n/** Rebuild `n` with every slot replaced by `f(slot)` \u2014 an IMMUTABLE structural\r\n *  map (never mutates the input). The traversal order matches `mathSlots`. */\r\nexport function mapMathSlots(n: MathNode, f: (child: MathNode) => MathNode): MathNode {\r\n  switch (n.type) {\r\n    case \"row\":\r\n      return { ...n, children: n.children.map(f) };\r\n    case \"frac\":\r\n      return { ...n, num: f(n.num), den: f(n.den) };\r\n    case \"script\":\r\n      return {\r\n        ...n,\r\n        base: f(n.base),\r\n        ...(n.sub ? { sub: f(n.sub) } : {}),\r\n        ...(n.sup ? { sup: f(n.sup) } : {}),\r\n      };\r\n    case \"radical\":\r\n      return { ...n, radicand: f(n.radicand), ...(n.index ? { index: f(n.index) } : {}) };\r\n    case \"fenced\":\r\n      return { ...n, child: f(n.child) };\r\n    case \"limit\":\r\n      return {\r\n        ...n,\r\n        base: f(n.base),\r\n        ...(n.under ? { under: f(n.under) } : {}),\r\n        ...(n.over ? { over: f(n.over) } : {}),\r\n      };\r\n    case \"nary\":\r\n      return {\r\n        ...n,\r\n        ...(n.sub ? { sub: f(n.sub) } : {}),\r\n        ...(n.sup ? { sup: f(n.sup) } : {}),\r\n        body: f(n.body),\r\n      };\r\n    case \"matrix\":\r\n      return { ...n, rows: n.rows.map((r) => r.map(f)) };\r\n    case \"phantom\":\r\n      return { ...n, child: f(n.child) };\r\n    default:\r\n      return n;\r\n  }\r\n}\r\n\r\n/** Depth-first visit of every node (self first, then slots). */\r\nexport function walkMath(n: MathNode, visit: (node: MathNode) => void): void {\r\n  visit(n);\r\n  for (const c of mathSlots(n)) walkMath(c, visit);\r\n}\r\n\r\n/** Plain-text approximation of an equation (for search, a11y, alt text). */\r\nexport function mathToPlainText(n: MathNode): string {\r\n  switch (n.type) {\r\n    case \"ident\":\r\n    case \"number\":\r\n    case \"op\":\r\n    case \"text\":\r\n      return n.text;\r\n    case \"space\":\r\n      return \" \";\r\n    case \"frac\":\r\n      return `${mathToPlainText(n.num)}/${mathToPlainText(n.den)}`;\r\n    case \"fenced\":\r\n      return `${n.open}${mathToPlainText(n.child)}${n.close}`;\r\n    case \"nary\":\r\n      return n.op + mathSlots(n).map(mathToPlainText).join(\"\");\r\n    default:\r\n      return mathSlots(n).map(mathToPlainText).join(\"\");\r\n  }\r\n}\r\n", "// Generic OOXML field-instruction parsing. Pure and layout-free, so import,\n// export, and the editor command layer all share it.\n//\n// A \"field\" in OOXML is a region delimited by w:fldChar begin/separate/end runs\n// with a w:instrText instruction (e.g. ` TOC \\o \"1-3\" \\h `, ` PAGEREF _Toc1 \\h `,\n// ` MYCHART \"sales-2026\" `). Word ships a fixed set of BUILT-IN field types it\n// knows how to render; everything else is a developer-defined CUSTOM field whose\n// result the host computes (see Document.fields + the editor's resolveField hook).\n// This module only classifies an instruction and splits out its name + arguments;\n// TOC has its own richer parser in ./toc.\n\n/** A field instruction split into its keyword and arguments. */\nexport interface ParsedFieldInstruction {\n  /** Field keyword, uppercased (e.g. \"TOC\", \"MYCHART\"). \"\" when the instruction\n   *  is blank. */\n  name: string;\n  /** Whitespace/quote-delimited tokens after the keyword (surrounding double\n   *  quotes stripped). Switches like `\\o` appear here verbatim. */\n  args: string[];\n  /** The instruction exactly as given (untrimmed). */\n  raw: string;\n}\n\n/** Field keywords Word renders itself \u2014 NOT treated as host-resolvable custom\n *  fields. TOC is built-in here too (the editor handles it on its own tocEntry\n *  path), so it is never captured as a generic custom field. */\nconst BUILTIN_FIELDS = new Set([\n  \"TOC\", \"PAGE\", \"NUMPAGES\", \"PAGEREF\", \"HYPERLINK\", \"REF\", \"SEQ\", \"STYLEREF\",\n  \"DATE\", \"TIME\", \"CREATEDATE\", \"SAVEDATE\", \"PRINTDATE\", \"EDITTIME\", \"FILENAME\",\n  \"FILESIZE\", \"AUTHOR\", \"LASTSAVEDBY\", \"TITLE\", \"SUBJECT\", \"KEYWORDS\", \"COMMENTS\",\n  \"NUMWORDS\", \"NUMCHARS\", \"TOA\", \"INDEX\", \"XE\", \"TC\", \"TA\", \"RD\",\n  \"FORMTEXT\", \"FORMCHECKBOX\", \"FORMDROPDOWN\", \"SYMBOL\", \"QUOTE\", \"IF\",\n  \"DOCPROPERTY\", \"DOCVARIABLE\", \"MERGEFIELD\", \"ADDRESSBLOCK\", \"GREETINGLINE\",\n  \"FILLIN\", \"ASK\", \"SET\", \"GOTOBUTTON\", \"MACROBUTTON\", \"EQ\", \"LISTNUM\",\n  \"BIBLIOGRAPHY\", \"CITATION\", \"SECTION\", \"SECTIONPAGES\", \"AUTONUM\", \"AUTONUMLGL\",\n  \"AUTONUMOUT\", \"INCLUDETEXT\", \"INCLUDEPICTURE\", \"LINK\", \"NOTEREF\",\n]);\n\n/** Is `name` one of Word's built-in field types (so NOT a custom field)? */\nexport function isBuiltinField(name: string): boolean {\n  return BUILTIN_FIELDS.has(name.trim().toUpperCase());\n}\n\n/** Tokenize a field instruction, honoring double-quoted arguments. */\nfunction tokenizeField(instr: string): string[] {\n  const out: string[] = [];\n  const re = /\"([^\"]*)\"|(\\S+)/g;\n  let m: RegExpExecArray | null;\n  while ((m = re.exec(instr)) !== null) out.push(m[1] !== undefined ? m[1] : m[2]!);\n  return out;\n}\n\n/** Parse a field instruction into its keyword + arguments. */\nexport function parseFieldInstruction(instr: string): ParsedFieldInstruction {\n  const tokens = tokenizeField(instr);\n  return { name: tokens.length > 0 ? tokens[0]!.toUpperCase() : \"\", args: tokens.slice(1), raw: instr };\n}\n\n/** Is this instruction a host-resolvable custom field (has a keyword and isn't a\n *  Word built-in)? Drives import capture + the editor's \"Update Field\" menu. */\nexport function isCustomFieldInstruction(instr: string): boolean {\n  const name = parseFieldInstruction(instr).name;\n  return name.length > 0 && !isBuiltinField(name);\n}\n", "// Field evaluation \u2014 pure, layout-free, so import, the editor, and the headless\n// render all agree. Two result shapes:\n//   \u2022 \"token\"  \u2014 layout-dependent fields (PAGE/NUMPAGES). The result run holds a\n//     `{page}`/`{pages}` token the layout engine re-substitutes per page (see\n//     engine.ts substituteTokens). The run's CharStyle.fieldId is what marks it a\n//     real field vs literal text.\n//   \u2022 \"runs\"   \u2014 static fields (DATE/TIME/IF), materialized once on insert/update.\n//\n// `spec` \u21C4 `instruction` round-trips via parseFieldSpec / buildInstruction; the\n// verbatim instruction stays the export source of truth (unknown switches survive).\n\nimport type { CharStyle, FieldSpec, IfOp, PageNumFmt, Run } from \"./model/document\";\nimport { parseFieldInstruction, type ParsedFieldInstruction } from \"./fields\";\nimport { textOfRuns } from \"./model/text\";\n\nexport interface FieldEvalCtx {\n  /** \"Now\" for DATE/TIME \u2014 passed in so evaluation stays pure/deterministic. */\n  now: Date;\n}\n\nexport type FieldEvalResult =\n  | { kind: \"runs\"; runs: Run[] }\n  | { kind: \"token\"; token: string };\n\nconst MONTHS = [\"January\", \"February\", \"March\", \"April\", \"May\", \"June\", \"July\", \"August\", \"September\", \"October\", \"November\", \"December\"];\nconst DAYS = [\"Sunday\", \"Monday\", \"Tuesday\", \"Wednesday\", \"Thursday\", \"Friday\", \"Saturday\"];\n\nconst cloneRuns = (runs: Run[]): Run[] => runs.map((r) => ({ text: r.text, style: { ...r.style } }));\n\n/** Token suffix for a page-number format (matches engine.ts `{page:fmt}` grammar). */\nconst numFmtToken = (f: PageNumFmt | undefined): string =>\n  f && f !== \"arabic\" ? `:${f}` : \"\";\n\n/** OOXML `\\* <fmt>` switch for a page-number format (matches export fieldInstr). */\nconst numFmtSwitch = (f: PageNumFmt | undefined): string =>\n  f === \"roman\" ? \" \\\\* roman\"\n  : f === \"Roman\" ? \" \\\\* ROMAN\"\n  : f === \"alpha\" ? \" \\\\* alphabetic\"\n  : f === \"Alpha\" ? \" \\\\* ALPHABETIC\"\n  : \"\";\n\n/** Format a Date with a Word `\\@` picture (subset): yyyy/yy, MMMM/MMM/MM/M,\n *  dddd/ddd/dd/d, HH/H, hh/h, mm/m, ss/s, AM/PM, am/pm. `'literal'` passes through. */\nexport function formatFieldDate(d: Date, fmt: string): string {\n  const pad = (n: number, w = 2): string => String(n).padStart(w, \"0\");\n  const h12 = ((d.getHours() + 11) % 12) + 1;\n  let out = \"\";\n  let i = 0;\n  while (i < fmt.length) {\n    if (fmt[i] === \"'\") {\n      const end = fmt.indexOf(\"'\", i + 1);\n      if (end < 0) { out += fmt.slice(i + 1); break; }\n      out += fmt.slice(i + 1, end);\n      i = end + 1;\n      continue;\n    }\n    const rest = fmt.slice(i);\n    const tok = (t: string): boolean => rest.startsWith(t);\n    if (tok(\"yyyy\")) { out += pad(d.getFullYear(), 4); i += 4; }\n    else if (tok(\"yy\")) { out += pad(d.getFullYear() % 100); i += 2; }\n    else if (tok(\"MMMM\")) { out += MONTHS[d.getMonth()]; i += 4; }\n    else if (tok(\"MMM\")) { out += MONTHS[d.getMonth()]!.slice(0, 3); i += 3; }\n    else if (tok(\"MM\")) { out += pad(d.getMonth() + 1); i += 2; }\n    else if (tok(\"M\")) { out += String(d.getMonth() + 1); i += 1; }\n    else if (tok(\"dddd\")) { out += DAYS[d.getDay()]; i += 4; }\n    else if (tok(\"ddd\")) { out += DAYS[d.getDay()]!.slice(0, 3); i += 3; }\n    else if (tok(\"dd\")) { out += pad(d.getDate()); i += 2; }\n    else if (tok(\"d\")) { out += String(d.getDate()); i += 1; }\n    else if (tok(\"HH\")) { out += pad(d.getHours()); i += 2; }\n    else if (tok(\"H\")) { out += String(d.getHours()); i += 1; }\n    else if (tok(\"hh\")) { out += pad(h12); i += 2; }\n    else if (tok(\"h\")) { out += String(h12); i += 1; }\n    else if (tok(\"mm\")) { out += pad(d.getMinutes()); i += 2; }\n    else if (tok(\"m\")) { out += String(d.getMinutes()); i += 1; }\n    else if (tok(\"ss\")) { out += pad(d.getSeconds()); i += 2; }\n    else if (tok(\"s\")) { out += String(d.getSeconds()); i += 1; }\n    else if (tok(\"AM/PM\")) { out += d.getHours() < 12 ? \"AM\" : \"PM\"; i += 5; }\n    else if (tok(\"am/pm\")) { out += d.getHours() < 12 ? \"am\" : \"pm\"; i += 5; }\n    else { out += fmt[i]; i += 1; }\n  }\n  return out;\n}\n\n/** Compare two literal operands; numeric when both parse as finite numbers, else string. */\nfunction compare(a: string, op: IfOp, b: string): boolean {\n  const na = Number(a);\n  const nb = Number(b);\n  const numeric = a.trim() !== \"\" && b.trim() !== \"\" && Number.isFinite(na) && Number.isFinite(nb);\n  const [x, y]: [number | string, number | string] = numeric ? [na, nb] : [a, b];\n  switch (op) {\n    case \"=\": return x === y;\n    case \"<>\": return x !== y;\n    case \"<\": return x < y;\n    case \">\": return x > y;\n    case \"<=\": return x <= y;\n    case \">=\": return x >= y;\n  }\n}\n\n/** The chosen branch of an IF field, as fresh (cloned) runs. */\nexport function evaluateIf(spec: Extract<FieldSpec, { type: \"IF\" }>): Run[] {\n  return cloneRuns(compare(spec.operandA, spec.op, spec.operandB) ? spec.trueRuns : spec.falseRuns);\n}\n\n/** Evaluate a built-in field to its display result. `baseStyle` styles DATE/TIME text. */\nexport function evaluateField(spec: FieldSpec, baseStyle: CharStyle, ctx: FieldEvalCtx): FieldEvalResult {\n  switch (spec.type) {\n    case \"PAGE\": return { kind: \"token\", token: `{page${numFmtToken(spec.numFmt)}}` };\n    case \"NUMPAGES\": return { kind: \"token\", token: \"{pages}\" };\n    case \"DATE\": return { kind: \"runs\", runs: [{ text: formatFieldDate(ctx.now, spec.format), style: { ...baseStyle } }] };\n    case \"TIME\": return { kind: \"runs\", runs: [{ text: formatFieldDate(ctx.now, spec.format), style: { ...baseStyle } }] };\n    case \"IF\": return { kind: \"runs\", runs: evaluateIf(spec) };\n  }\n}\n\n// --- spec \u21C4 instruction --------------------------------------------------------\n\nconst IF_OPS = new Set<string>([\"=\", \"<>\", \"<\", \">\", \"<=\", \">=\"]);\n\nfunction numFmtFromInstr(raw: string): PageNumFmt | undefined {\n  if (/\\\\\\*\\s*ROMAN\\b/.test(raw)) return \"Roman\";\n  if (/\\\\\\*\\s*roman\\b/.test(raw)) return \"roman\";\n  if (/\\\\\\*\\s*ALPHABETIC\\b/.test(raw)) return \"Alpha\";\n  if (/\\\\\\*\\s*alphabetic\\b/.test(raw)) return \"alpha\";\n  return undefined;\n}\n\n/** The `\\@ \"...\"` (or `\\@ token`) date/time picture from an instruction. */\nfunction atFormat(raw: string): string | undefined {\n  return raw.match(/\\\\@\\s*\"([^\"]*)\"/)?.[1] ?? raw.match(/\\\\@\\s*(\\S+)/)?.[1];\n}\n\n/** Parse a built-in field instruction into a typed spec, or undefined (custom /\n *  unsupported / unparseable). IF result runs use `baseStyle` (plain text). */\nexport function parseFieldSpec(parsed: ParsedFieldInstruction, baseStyle: CharStyle): FieldSpec | undefined {\n  switch (parsed.name) {\n    case \"PAGE\": { const f = numFmtFromInstr(parsed.raw); return f ? { type: \"PAGE\", numFmt: f } : { type: \"PAGE\" }; }\n    case \"NUMPAGES\": { const f = numFmtFromInstr(parsed.raw); return f ? { type: \"NUMPAGES\", numFmt: f } : { type: \"NUMPAGES\" }; }\n    case \"DATE\": return { type: \"DATE\", format: atFormat(parsed.raw) ?? \"M/d/yyyy\" };\n    case \"TIME\": return { type: \"TIME\", format: atFormat(parsed.raw) ?? \"h:mm AM/PM\" };\n    case \"IF\": {\n      const [operandA, op, operandB, trueText, falseText] = parsed.args;\n      if (operandA === undefined || op === undefined || operandB === undefined || !IF_OPS.has(op)) return undefined;\n      return {\n        type: \"IF\", operandA, op: op as IfOp, operandB,\n        trueRuns: [{ text: trueText ?? \"\", style: { ...baseStyle } }],\n        falseRuns: [{ text: falseText ?? \"\", style: { ...baseStyle } }],\n      };\n    }\n    default: return undefined;\n  }\n}\n\n/** Synthesize the verbatim instruction for a typed spec (inverse of parseFieldSpec). */\nexport function buildInstruction(spec: FieldSpec): string {\n  switch (spec.type) {\n    case \"PAGE\": return ` PAGE${numFmtSwitch(spec.numFmt)} \\\\* MERGEFORMAT `;\n    case \"NUMPAGES\": return ` NUMPAGES \\\\* MERGEFORMAT `;\n    case \"DATE\": return ` DATE \\\\@ \"${spec.format}\" `;\n    case \"TIME\": return ` TIME \\\\@ \"${spec.format}\" `;\n    case \"IF\": return ` IF ${spec.operandA} ${spec.op} ${spec.operandB} \"${textOfRuns(spec.trueRuns)}\" \"${textOfRuns(spec.falseRuns)}\" `;\n  }\n}\n\n/** Convenience: build a field name from a spec (uppercased keyword). */\nexport function fieldName(spec: FieldSpec): string {\n  return spec.type;\n}\n\nexport { parseFieldInstruction };\n"],
-  "mappings": "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",
-  "names": []
-}