@forevka/wordcanvas 0.7.2 → 0.7.3

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

@@ -1,7 +0,0 @@
-{
-  "version": 3,
-  "sources": ["../../shared/src/model/text.ts", "../../shared/src/model/lists.ts", "../../shared/src/model/ops.ts", "../../shared/src/ids.ts", "../../shared/src/toc.ts", "../../shared/src/model/stylesheet.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/** 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  paragraphsInBlocks(doc.section[band] ?? [], true);\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/** 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. */\r\nexport const paragraphsOf = (doc: Document): Paragraph[] => [\r\n  ...paragraphsInBlocks(doc.blocks, true),\r\n  ...BAND_CONTAINERS.flatMap((band) => bandParagraphs(doc, band)),\r\n  ...Object.values(doc.footnotes ?? {}).flat(),\r\n];\r\n\r\nexport const blockById = (doc: Document, blockId: string): Paragraph | undefined =>\r\n  paragraphsOf(doc).find((b) => b.id === blockId);\r\n\r\nexport const blockIndexOf = (doc: Document, blockId: string): number =>\r\n  paragraphsOf(doc).findIndex((b) => b.id === blockId);\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  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\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  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  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 === \"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", "// 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 ?? \"\u2022\";\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\nconst BULLETS = [\"\u2022\", \"\u25E6\", \"\u25AA\"];\nconst NUMBER_FORMATS: ListNumberFormat[] = [\"decimal\", \"lowerLetter\", \"lowerRoman\"];\n\nexport function defaultListDefinition(kind: \"bullet\" | \"decimal\"): ListDefinition {\n  const levels: ListLevel[] = [];\n  for (let i = 0; i < 9; i++) {\n    if (kind === \"bullet\") {\n      levels.push({\n        format: \"bullet\",\n        text: \"\",\n        bulletChar: BULLETS[i % 3]!,\n        indentLeftPx: 24 + i * 24,\n        hangingPx: 18,\n        start: 1,\n      });\n    } else {\n      levels.push({\n        format: NUMBER_FORMATS[i % 3]!,\n        text: `%${i + 1}.`,\n        indentLeftPx: 24 + i * 24,\n        hangingPx: 22,\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 < 9; i++) {\n    levels.push({ format: \"bullet\", text: \"\", bulletChar: char, indentLeftPx: 24 + i * 24, hangingPx: 18, 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 < 9; i++) {\n    levels.push({ format, text: `%${i + 1}${suffix}`, indentLeftPx: 24 + i * 24, hangingPx: 22, 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 < 9; 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: 24 + i * 24,\n      hangingPx: 24 + i * 8, // compound markers widen with depth\n      start: 1,\n    });\n  }\n  return { id: DEFAULT_MULTILEVEL_LIST_ID, levels };\n}\n", "// All mutation flows through operations. Applying an op returns the new document\n// (structurally shared), the op's exact INVERSE (undo is free), and a position\n// mapper so selections survive edits. This seam is also where OT/CRDT\n// collaboration would slot in later.\n\nimport type {\n  BandContainer,\n  Block,\n  BookmarkRange,\n  CharStyle,\n  Document,\n  FieldDef,\n  ImageBlock,\n  ParaStyle,\n  Paragraph,\n  Run,\n  SdtProps,\n  TableBlock,\n  TableCell,\n  TableRow,\n} from \"./document\";\nimport { BAND_CONTAINERS } from \"./document\";\nimport type { DocPosition } from \"./position\";\nimport {\n  locateParagraph,\n  paragraphAt,\n  replaceParagraphAt,\n  styleAtRuns,\n  textOfRuns,\n  type ParaLocation,\n} from \"./text\";\n\n/** setImageProps payload. `wrap` and `anchor` are mutually-exclusive states, so\n *  each accepts `null` as an explicit \"clear this field\" sentinel (plain\n *  `undefined` means \"leave unchanged\", which exactOptionalPropertyTypes also\n *  needs to keep these distinguishable). */\nexport interface ImagePropsPatch {\n  widthPx?: number;\n  heightPx?: number;\n  align?: ImageBlock[\"align\"];\n  wrap?: ImageBlock[\"wrap\"] | null;\n  anchor?: ImageBlock[\"anchor\"] | null;\n}\n\nexport type Op =\n  | { type: \"insertText\"; at: DocPosition; text: string; style?: CharStyle }\n  | { type: \"insertRuns\"; at: DocPosition; runs: Run[] }\n  | { type: \"deleteRange\"; blockId: string; start: number; end: number }\n  | { type: \"setRuns\"; blockId: string; runs: Run[] }\n  | { type: \"setParaStyle\"; blockId: string; patch: Partial<ParaStyle> }\n  | { type: \"splitParagraph\"; at: DocPosition; newBlockId: string; newStyle?: ParaStyle }\n  | { type: \"mergeParagraphs\"; firstBlockId: string }\n  | { type: \"insertBlock\"; index: number; block: Block; where?: Container }\n  | { type: \"removeBlock\"; blockId: string }\n  | { type: \"setImageProps\"; blockId: string; patch: ImagePropsPatch }\n  | { type: \"setTableRow\"; tableId: string; rowIndex: number; row: TableRow }\n  | { type: \"setTableStructure\"; tableId: string; rows: TableRow[]; colFractions?: number[] }\n  | { type: \"setTableStyleRef\"; tableId: string; styleId: string | null; condOverrides?: import(\"./document\").TableCondOverrides | null }\n  | { type: \"setTableColFractions\"; blockId: string; fractions: number[] }\n  | { type: \"insertTableRow\"; tableId: string; rowIndex: number; row: TableRow }\n  | { type: \"removeTableRow\"; tableId: string; rowIndex: number }\n  | { type: \"insertTableColumn\"; tableId: string; colIndex: number; cells: TableCell[]; fractions?: number[] }\n  | { type: \"removeTableColumn\"; tableId: string; colIndex: number }\n  | { type: \"setStylesheet\"; stylesheet: import(\"./stylesheet\").Stylesheet }\n  | { type: \"setTableStyleSheet\"; tableStyles: Record<string, import(\"./tableStyles\").TableStyle> }\n  | { type: \"setListDefinition\"; listId: string; def: import(\"./lists\").ListDefinition | null }\n  | { type: \"setSectionProps\"; geometry: SectionGeometry }\n  | { type: \"setSectionBand\"; band: BandContainer; blocks: Block[] | null }\n  | { type: \"setFootnote\"; noteId: string; paras: Paragraph[] | null }\n  | { type: \"setSdtProps\"; id: string; props: SdtProps | null }\n  | { type: \"setField\"; id: string; def: FieldDef | null }\n  | { type: \"setTocInstruction\"; instruction: string | null }\n  | { type: \"setBookmark\"; name: string; range: BookmarkRange | null };\n\n/** Page-setup fields of the final section (`doc.section`). Bands are NOT here \u2014\n *  they change through container ops; mid-document sections change through\n *  setParaStyle on their break paragraph's `sectionBreak.props`. */\nexport interface SectionGeometry {\n  pageWidthPx: number;\n  pageHeightPx: number;\n  marginPx: { top: number; right: number; bottom: number; left: number };\n  /** `null` = single column (the explicit \"off\" \u2014 SectionPatch distinguishes it\n   *  from \"inherit\"). `sep`/`cols` carry the separator line and per-column\n   *  widths respectively. */\n  columns: { count: number; gapPx: number; sep?: boolean; cols?: import(\"./document\").ColumnEntry[] } | null;\n  /** `null` = continue numbering from the previous section. */\n  pageNumberStart: number | null;\n  /** `null` = inherit (center band in margin). px from page top to header top. */\n  headerDistancePx: number | null;\n  /** `null` = inherit (center band in margin). px from page bottom to footer bottom. */\n  footerDistancePx: number | null;\n  /** `null` = no page fill. \"#rrggbb\". */\n  pageColorHex: string | null;\n  /** `null` = no page border. */\n  pageBorders: import(\"./document\").PageBorders | null;\n}\n\n/** Top-level block containers: the body, or one of the six margin-band stories\n *  (default header/footer + first/even variants). */\nexport type Container = \"body\" | BandContainer;\n\nexport interface ApplyResult {\n  doc: Document;\n  inverse: Op;\n  /** Remaps any stored position across this edit (selection, bookmarks). */\n  mapPosition(pos: DocPosition): DocPosition;\n  dirtyBlockIds: string[];\n}\n\n// ---------------------------------------------------------------------------\n// Run-list surgery (pure helpers)\n\nexport function styleEq(a: CharStyle, b: CharStyle): boolean {\n  return (\n    a.fontFamily === b.fontFamily &&\n    a.fontSizePx === b.fontSizePx &&\n    a.bold === b.bold &&\n    a.italic === b.italic &&\n    a.underline === b.underline &&\n    a.strikethrough === b.strikethrough &&\n    a.color === b.color &&\n    !!a.hidden === !!b.hidden && // hidden runs must never merge with visible ones\n    (a.letterSpacingPx ?? 0) === (b.letterSpacingPx ?? 0) &&\n    a.highlightColor === b.highlightColor &&\n    a.verticalAlign === b.verticalAlign &&\n    a.link === b.link &&\n    a.footnoteRef === b.footnoteRef && // adjacent refs must never merge into one run\n    a.sdtId === b.sdtId && // content-control boundaries survive normalization\n    a.fieldId === b.fieldId // inline-field boundaries survive normalization\n  );\n}\n\n/** Merge equal-styled neighbors, drop empties. An all-empty paragraph keeps ONE\n *  empty run so the paragraph mark still carries a style (Word behavior). */\nexport function normalizeRuns(runs: Run[], fallback: CharStyle): Run[] {\n  const nonEmpty = runs.filter((r) => r.text.length > 0);\n  if (nonEmpty.length === 0) return [{ text: \"\", style: runs[0]?.style ?? fallback }];\n  const out: Run[] = [{ ...nonEmpty[0]! }];\n  for (let i = 1; i < nonEmpty.length; i++) {\n    const r = nonEmpty[i]!;\n    const last = out[out.length - 1]!;\n    if (styleEq(last.style, r.style)) last.text += r.text;\n    else out.push({ ...r });\n  }\n  return out;\n}\n\n/** Split a run list at a UTF-16 offset. */\nexport function splitRunsAt(runs: Run[], offset: number): [Run[], Run[]] {\n  const head: Run[] = [];\n  const tail: Run[] = [];\n  let cum = 0;\n  for (const r of runs) {\n    const end = cum + r.text.length;\n    if (end <= offset) head.push(r);\n    else if (cum >= offset) tail.push(r);\n    else {\n      head.push({ text: r.text.slice(0, offset - cum), style: r.style });\n      tail.push({ text: r.text.slice(offset - cum), style: r.style });\n    }\n    cum = end;\n  }\n  return [head, tail];\n}\n\nexport function sliceRuns(runs: Run[], start: number, end: number): Run[] {\n  const [, fromStart] = splitRunsAt(runs, start);\n  const [middle] = splitRunsAt(fromStart, end - start);\n  return middle;\n}\n\nfunction fallbackStyle(runs: Run[], offset: number): CharStyle {\n  return (\n    styleAtRuns(runs, offset) ?? {\n      fontFamily: \"Georgia, serif\",\n      fontSizePx: 16,\n      bold: false,\n      italic: false,\n      underline: false,\n      strikethrough: false,\n      color: \"#202124\",\n    }\n  );\n}\n\nexport function insertTextInRuns(runs: Run[], offset: number, text: string, style?: CharStyle): Run[] {\n  const st = style ?? fallbackStyle(runs, offset);\n  const [head, tail] = splitRunsAt(runs, offset);\n  return normalizeRuns([...head, { text, style: st }, ...tail], st);\n}\n\nexport function insertRunsInRuns(runs: Run[], offset: number, inserted: Run[]): Run[] {\n  const [head, tail] = splitRunsAt(runs, offset);\n  return normalizeRuns([...head, ...inserted, ...tail], fallbackStyle(runs, offset));\n}\n\nexport function deleteInRuns(runs: Run[], start: number, end: number): Run[] {\n  const [head, fromStart] = splitRunsAt(runs, start);\n  const [, tail] = splitRunsAt(fromStart, end - start);\n  return normalizeRuns([...head, ...tail], fallbackStyle(runs, start));\n}\n\nexport function applyStylePatchToRuns(\n  runs: Run[],\n  start: number,\n  end: number,\n  patch: Partial<CharStyle>,\n): Run[] {\n  const [head, fromStart] = splitRunsAt(runs, start);\n  const [middle, tail] = splitRunsAt(fromStart, end - start);\n  const styled = middle.map((r) => ({ text: r.text, style: { ...r.style, ...patch } }));\n  return normalizeRuns([...head, ...styled, ...tail], fallbackStyle(runs, start));\n}\n\n/** Rewrite the TEXT of runs in [start,end) through `fn`, preserving each run's\n *  style. `fn` receives the whole covered string (so it can do context-aware\n *  transforms like sentence case) and must return a string of the SAME length \u2014\n *  if the length changes the slice is left untouched (run offsets must stay\n *  stable). Used by change-case; transforms here are 1:1 per character. */\nexport function mapTextInRuns(\n  runs: Run[],\n  start: number,\n  end: number,\n  fn: (covered: string) => string,\n): Run[] {\n  const [head, fromStart] = splitRunsAt(runs, start);\n  const [middle, tail] = splitRunsAt(fromStart, end - start);\n  const original = middle.map((r) => r.text).join(\"\");\n  const next = fn(original);\n  let i = 0;\n  const out =\n    next.length === original.length\n      ? middle.map((r) => {\n          const text = next.slice(i, i + r.text.length);\n          i += r.text.length;\n          return { text, style: r.style };\n        })\n      : middle;\n  return normalizeRuns([...head, ...out, ...tail], fallbackStyle(runs, start));\n}\n\n// ---------------------------------------------------------------------------\n// applyOp\n\nconst identity = (p: DocPosition): DocPosition => p;\n\n/** Content ops accept ANY paragraph (top-level or table cell). */\nfunction mustLocate(doc: Document, blockId: string): { loc: ParaLocation; block: Paragraph } {\n  const loc = locateParagraph(doc, blockId);\n  if (!loc) throw new Error(`paragraph ${blockId} not found`);\n  return { loc, block: paragraphAt(doc, loc) };\n}\n\n// ---- container plumbing: structural ops work on the body OR a band story ----\n\nexport function containerBlocks(doc: Document, where: Container): Block[] {\n  return where === \"body\" ? doc.blocks : (doc.section[where] ?? []);\n}\n\nfunction withContainerBlocks(doc: Document, where: Container, blocks: Block[]): Document {\n  if (where === \"body\") return { ...doc, blocks };\n  return { ...doc, section: { ...doc.section, [where]: blocks } };\n}\n\n/** Which container holds this TOP-LEVEL block (paragraphs in table cells are\n *  not top-level and return null). */\nexport function containerOf(doc: Document, blockId: string): { where: Container; index: number } | null {\n  for (const where of [\"body\", ...BAND_CONTAINERS] as Container[]) {\n    const index = containerBlocks(doc, where).findIndex((b) => b.id === blockId);\n    if (index >= 0) return { where, index };\n  }\n  return null;\n}\n\nfunction mustTable(doc: Document, blockId: string): { where: Container; bi: number; block: TableBlock } {\n  const found = containerOf(doc, blockId);\n  const block = found ? containerBlocks(doc, found.where)[found.index] : undefined;\n  if (!found || !block || block.kind !== \"table\") throw new Error(`table ${blockId} not found`);\n  return { where: found.where, bi: found.index, block };\n}\n\nfunction replaceTable(doc: Document, where: Container, bi: number, table: TableBlock): Document {\n  const blocks = containerBlocks(doc, where).slice();\n  blocks[bi] = { ...table, revision: table.revision + 1 };\n  return withContainerBlocks(doc, where, blocks);\n}\n\n/** Path-clone a table (body or band) replacing one cell's block list\n *  (revision bumped). */\nfunction replaceCellBlocks(\n  doc: Document,\n  where: Container,\n  bi: number,\n  ri: number,\n  ci: number,\n  cellBlocks: Block[],\n): Document {\n  const blocks = containerBlocks(doc, where).slice();\n  const table = blocks[bi] as TableBlock;\n  const rows = table.rows.slice();\n  const row = { cells: rows[ri]!.cells.slice() };\n  row.cells[ci] = { ...row.cells[ci]!, blocks: cellBlocks };\n  rows[ri] = row;\n  blocks[bi] = { ...table, rows, revision: table.revision + 1 };\n  return withContainerBlocks(doc, where, blocks);\n}\n\n/** First caret-capable paragraph in a set of rows (cells may start with images). */\nexport function firstParagraphInRows(rows: TableRow[]): Paragraph | undefined {\n  for (const row of rows) {\n    for (const cell of row.cells) {\n      for (const b of cell.blocks) if (b.kind === \"paragraph\") return b;\n    }\n  }\n  return undefined;\n}\n\n/** Find an image block anywhere editable: top-level containers or table cells. */\nexport type ImageLocation =\n  | { kind: \"top\"; where: Container; index: number; image: ImageBlock }\n  | { kind: \"cell\"; bi: number; ri: number; ci: number; ii: number; image: ImageBlock };\n\nexport function locateImage(doc: Document, blockId: string): ImageLocation | null {\n  const found = containerOf(doc, blockId);\n  if (found) {\n    const block = containerBlocks(doc, found.where)[found.index];\n    if (block?.kind === \"image\") return { kind: \"top\", where: found.where, index: found.index, image: block };\n    return null;\n  }\n  for (let bi = 0; bi < doc.blocks.length; bi++) {\n    const b = doc.blocks[bi]!;\n    if (b.kind !== \"table\") continue;\n    for (let ri = 0; ri < b.rows.length; ri++) {\n      const row = b.rows[ri]!;\n      for (let ci = 0; ci < row.cells.length; ci++) {\n        const cell = row.cells[ci]!;\n        for (let ii = 0; ii < cell.blocks.length; ii++) {\n          const cb = cell.blocks[ii]!;\n          if (cb.kind === \"image\" && cb.id === blockId) return { kind: \"cell\", bi, ri, ci, ii, image: cb };\n        }\n      }\n    }\n  }\n  return null;\n}\n\n/** The table's true grid-column count: the widest row measured in GRID columns,\n *  not cells \u2014 colSpan widens a cell and a rowSpan from an earlier row leaves a\n *  hole that this row's cells shift past (HTML table model). Counting cells\n *  alone undercounts any row with a colSpan or a vertical-merge hole. */\nexport function gridColumnCount(t: TableBlock): number {\n  let maxCols = 1;\n  const rowsRemaining: number[] = [];\n  for (const row of t.rows) {\n    let col = 0;\n    for (const cell of row.cells) {\n      while ((rowsRemaining[col] ?? 0) > 0) col++;\n      const span = Math.max(1, cell.colSpan ?? 1);\n      const rowSpan = Math.max(1, cell.rowSpan ?? 1);\n      if (rowSpan > 1) for (let k = 0; k < span; k++) rowsRemaining[col + k] = rowSpan;\n      col += span;\n    }\n    maxCols = Math.max(maxCols, col);\n    for (let c = 0; c < rowsRemaining.length; c++) if (rowsRemaining[c]! > 0) rowsRemaining[c]!--;\n  }\n  return maxCols;\n}\n\n/** Column fractions normalized to the table's column count. */\nexport function effectiveFractions(t: TableBlock): number[] {\n  const n = gridColumnCount(t);\n  if (t.colFractions && t.colFractions.length === n) return t.colFractions;\n  return Array.from({ length: n }, () => 1 / n);\n}\n\nfunction bump(block: Paragraph, runs: Run[]): Paragraph {\n  return { ...block, runs, revision: block.revision + 1 };\n}\n\nexport function applyOp(doc: Document, op: Op): ApplyResult {\n  switch (op.type) {\n    case \"insertText\": {\n      const { loc, block } = mustLocate(doc, op.at.blockId);\n      const runs = insertTextInRuns(block.runs, op.at.offset, op.text, op.style);\n      const len = op.text.length;\n      return {\n        doc: replaceParagraphAt(doc, loc, bump(block, runs)),\n        inverse: { type: \"deleteRange\", blockId: block.id, start: op.at.offset, end: op.at.offset + len },\n        mapPosition: (p) =>\n          p.blockId === block.id && p.offset >= op.at.offset\n            ? { blockId: p.blockId, offset: p.offset + len }\n            : p,\n        dirtyBlockIds: [block.id],\n      };\n    }\n\n    case \"insertRuns\": {\n      const { loc, block } = mustLocate(doc, op.at.blockId);\n      const len = textOfRuns(op.runs).length;\n      const runs = insertRunsInRuns(block.runs, op.at.offset, op.runs);\n      return {\n        doc: replaceParagraphAt(doc, loc, bump(block, runs)),\n        inverse: { type: \"deleteRange\", blockId: block.id, start: op.at.offset, end: op.at.offset + len },\n        mapPosition: (p) =>\n          p.blockId === block.id && p.offset >= op.at.offset\n            ? { blockId: p.blockId, offset: p.offset + len }\n            : p,\n        dirtyBlockIds: [block.id],\n      };\n    }\n\n    case \"deleteRange\": {\n      const { loc, block } = mustLocate(doc, op.blockId);\n      const removed = sliceRuns(block.runs, op.start, op.end);\n      const runs = deleteInRuns(block.runs, op.start, op.end);\n      const len = op.end - op.start;\n      return {\n        doc: replaceParagraphAt(doc, loc, bump(block, runs)),\n        inverse: { type: \"insertRuns\", at: { blockId: block.id, offset: op.start }, runs: removed },\n        mapPosition: (p) => {\n          if (p.blockId !== block.id || p.offset <= op.start) return p;\n          return { blockId: p.blockId, offset: p.offset >= op.end ? p.offset - len : op.start };\n        },\n        dirtyBlockIds: [block.id],\n      };\n    }\n\n    case \"setRuns\": {\n      const { loc, block } = mustLocate(doc, op.blockId);\n      return {\n        doc: replaceParagraphAt(doc, loc, bump(block, op.runs)),\n        inverse: { type: \"setRuns\", blockId: block.id, runs: block.runs },\n        mapPosition: identity, // callers use setRuns for length-preserving restyles\n        dirtyBlockIds: [block.id],\n      };\n    }\n\n    case \"setParaStyle\": {\n      const { loc, block } = mustLocate(doc, op.blockId);\n      const oldPatch: Partial<ParaStyle> = {};\n      for (const key of Object.keys(op.patch) as (keyof ParaStyle)[]) {\n        // @ts-expect-error \u2014 keyed copy of the previous values for the inverse\n        oldPatch[key] = block.style[key];\n      }\n      const styled: Paragraph = {\n        ...block,\n        style: { ...block.style, ...op.patch },\n        revision: block.revision + 1,\n      };\n      return {\n        doc: replaceParagraphAt(doc, loc, styled),\n        inverse: { type: \"setParaStyle\", blockId: block.id, patch: oldPatch },\n        mapPosition: identity,\n        dirtyBlockIds: [block.id],\n      };\n    }\n\n    case \"splitParagraph\": {\n      const loc = locateParagraph(doc, op.at.blockId);\n      if (!loc) throw new Error(`paragraph ${op.at.blockId} not found`);\n      const block = paragraphAt(doc, loc);\n      const [headRuns, tailRuns] = splitRunsAt(block.runs, op.at.offset);\n      const carry = fallbackStyle(block.runs, op.at.offset);\n      const head = bump(block, normalizeRuns(headRuns, carry));\n      const tail: Paragraph = {\n        kind: \"paragraph\",\n        id: op.newBlockId,\n        revision: 0,\n        runs: normalizeRuns(tailRuns, carry),\n        style: op.newStyle ?? { ...block.style },\n      };\n      let next: Document;\n      if (loc.kind === \"cell\") {\n        const table = containerBlocks(doc, loc.where)[loc.bi] as TableBlock;\n        const cellBlocks = table.rows[loc.ri]!.cells[loc.ci]!.blocks.slice();\n        cellBlocks.splice(loc.pi, 1, head, tail);\n        next = replaceCellBlocks(doc, loc.where, loc.bi, loc.ri, loc.ci, cellBlocks);\n      } else if (loc.kind === \"footnote\") {\n        const paras = doc.footnotes![loc.noteId]!.slice();\n        paras.splice(loc.pi, 1, head, tail);\n        next = { ...doc, footnotes: { ...doc.footnotes, [loc.noteId]: paras } };\n      } else {\n        const where: Container = loc.kind === \"band\" ? loc.band : \"body\";\n        const blocks = containerBlocks(doc, where).slice();\n        blocks.splice(loc.bi, 1, head, tail);\n        next = withContainerBlocks(doc, where, blocks);\n      }\n      return {\n        doc: next,\n        inverse: { type: \"mergeParagraphs\", firstBlockId: block.id },\n        mapPosition: (p) =>\n          p.blockId === block.id && p.offset >= op.at.offset\n            ? { blockId: op.newBlockId, offset: p.offset - op.at.offset }\n            : p,\n        dirtyBlockIds: [block.id, op.newBlockId],\n      };\n    }\n\n    case \"mergeParagraphs\": {\n      const loc = locateParagraph(doc, op.firstBlockId);\n      if (!loc) throw new Error(`paragraph ${op.firstBlockId} not found`);\n      const block = paragraphAt(doc, loc);\n      let nextPara: Paragraph;\n      if (loc.kind === \"cell\") {\n        const table = containerBlocks(doc, loc.where)[loc.bi] as TableBlock;\n        const candidate = table.rows[loc.ri]!.cells[loc.ci]!.blocks[loc.pi + 1];\n        if (!candidate || candidate.kind !== \"paragraph\") {\n          throw new Error(\"mergeParagraphs: no next paragraph in cell\");\n        }\n        nextPara = candidate;\n      } else if (loc.kind === \"footnote\") {\n        const candidate = doc.footnotes![loc.noteId]![loc.pi + 1];\n        if (!candidate) throw new Error(\"mergeParagraphs: no next paragraph in footnote\");\n        nextPara = candidate;\n      } else {\n        const where: Container = loc.kind === \"band\" ? loc.band : \"body\";\n        const candidate = containerBlocks(doc, where)[loc.bi + 1];\n        if (!candidate || candidate.kind !== \"paragraph\") {\n          throw new Error(\"mergeParagraphs: no next paragraph\");\n        }\n        nextPara = candidate;\n      }\n      const headLen = textOfRuns(block.runs).length;\n      const merged = bump(\n        block,\n        normalizeRuns([...block.runs, ...nextPara.runs], fallbackStyle(block.runs, headLen)),\n      );\n      let next: Document;\n      if (loc.kind === \"cell\") {\n        const table = containerBlocks(doc, loc.where)[loc.bi] as TableBlock;\n        const cellBlocks = table.rows[loc.ri]!.cells[loc.ci]!.blocks.slice();\n        cellBlocks.splice(loc.pi, 2, merged);\n        next = replaceCellBlocks(doc, loc.where, loc.bi, loc.ri, loc.ci, cellBlocks);\n      } else if (loc.kind === \"footnote\") {\n        const paras = doc.footnotes![loc.noteId]!.slice();\n        paras.splice(loc.pi, 2, merged);\n        next = { ...doc, footnotes: { ...doc.footnotes, [loc.noteId]: paras } };\n      } else {\n        const where: Container = loc.kind === \"band\" ? loc.band : \"body\";\n        const blocks = containerBlocks(doc, where).slice();\n        blocks.splice(loc.bi, 2, merged);\n        next = withContainerBlocks(doc, where, blocks);\n      }\n      return {\n        doc: next,\n        inverse: {\n          type: \"splitParagraph\",\n          at: { blockId: block.id, offset: headLen },\n          newBlockId: nextPara.id,\n          newStyle: nextPara.style,\n        },\n        mapPosition: (p) =>\n          p.blockId === nextPara.id ? { blockId: block.id, offset: headLen + p.offset } : p,\n        dirtyBlockIds: [block.id, nextPara.id],\n      };\n    }\n\n    case \"insertBlock\": {\n      const where = op.where ?? \"body\";\n      const blocks = containerBlocks(doc, where).slice();\n      blocks.splice(op.index, 0, op.block);\n      return {\n        doc: withContainerBlocks(doc, where, blocks),\n        inverse: { type: \"removeBlock\", blockId: op.block.id },\n        mapPosition: identity,\n        dirtyBlockIds: [op.block.id],\n      };\n    }\n\n    case \"removeBlock\": {\n      const found = containerOf(doc, op.blockId);\n      if (!found) throw new Error(`block ${op.blockId} not found`);\n      const blocks = containerBlocks(doc, found.where).slice();\n      const block = blocks[found.index]!;\n      blocks.splice(found.index, 1);\n      const neighbor = blocks[Math.min(found.index, blocks.length - 1)];\n      return {\n        doc: withContainerBlocks(doc, found.where, blocks),\n        inverse: { type: \"insertBlock\", index: found.index, block, where: found.where },\n        mapPosition: (p) =>\n          p.blockId === op.blockId && neighbor\n            ? { blockId: neighbor.id, offset: 0 }\n            : p,\n        dirtyBlockIds: [op.blockId],\n      };\n    }\n\n    case \"setImageProps\": {\n      const loc = locateImage(doc, op.blockId);\n      if (!loc) throw new Error(`image ${op.blockId} not found`);\n      const block = loc.image;\n      // Inverse restores prior values; a field absent before is cleared (null)\n      // on undo. wrap/anchor use null to mean \"clear\" (they're exclusive states).\n      const oldPatch: ImagePropsPatch = {};\n      if (op.patch.widthPx !== undefined) oldPatch.widthPx = block.widthPx;\n      if (op.patch.heightPx !== undefined) oldPatch.heightPx = block.heightPx;\n      if (op.patch.align !== undefined) oldPatch.align = block.align;\n      if (op.patch.wrap !== undefined) oldPatch.wrap = block.wrap ?? null;\n      if (op.patch.anchor !== undefined) oldPatch.anchor = block.anchor ?? null;\n      const updated: ImageBlock = { ...block, revision: block.revision + 1 };\n      if (op.patch.widthPx !== undefined) updated.widthPx = op.patch.widthPx;\n      if (op.patch.heightPx !== undefined) updated.heightPx = op.patch.heightPx;\n      if (op.patch.align !== undefined) updated.align = op.patch.align;\n      if (op.patch.wrap !== undefined) {\n        if (op.patch.wrap === null) delete updated.wrap;\n        else updated.wrap = op.patch.wrap;\n      }\n      if (op.patch.anchor !== undefined) {\n        if (op.patch.anchor === null) delete updated.anchor;\n        else updated.anchor = op.patch.anchor;\n      }\n      let next: Document;\n      if (loc.kind === \"top\") {\n        const blocks = containerBlocks(doc, loc.where).slice();\n        blocks[loc.index] = updated;\n        next = withContainerBlocks(doc, loc.where, blocks);\n      } else {\n        const table = doc.blocks[loc.bi] as TableBlock;\n        const cellBlocks = table.rows[loc.ri]!.cells[loc.ci]!.blocks.slice();\n        cellBlocks[loc.ii] = updated;\n        next = replaceCellBlocks(doc, \"body\", loc.bi, loc.ri, loc.ci, cellBlocks); // locateImage cells are body-only\n\n      }\n      return {\n        doc: next,\n        inverse: { type: \"setImageProps\", blockId: op.blockId, patch: oldPatch },\n        mapPosition: identity,\n        dirtyBlockIds: [op.blockId],\n      };\n    }\n\n    case \"setTableColFractions\": {\n      const { where, bi, block } = mustTable(doc, op.blockId);\n      const old = effectiveFractions(block);\n      return {\n        doc: replaceTable(doc, where, bi, { ...block, colFractions: op.fractions }),\n        inverse: { type: \"setTableColFractions\", blockId: op.blockId, fractions: old },\n        mapPosition: identity,\n        dirtyBlockIds: [op.blockId],\n      };\n    }\n\n    case \"setTableRow\": {\n      const { where, bi, block } = mustTable(doc, op.tableId);\n      const old = block.rows[op.rowIndex];\n      if (!old) throw new Error(\"setTableRow: no such row\");\n      const removedIds = new Set(old.cells.flatMap((c) => c.blocks.map((p) => p.id)));\n      const rows = block.rows.slice();\n      rows[op.rowIndex] = op.row;\n      const fallback = firstParagraphInRows([op.row]);\n      return {\n        doc: replaceTable(doc, where, bi, { ...block, rows }),\n        inverse: { type: \"setTableRow\", tableId: op.tableId, rowIndex: op.rowIndex, row: old },\n        mapPosition: (p) => {\n          if (!removedIds.has(p.blockId)) return p;\n          // position survives if its paragraph still exists in the new row\n          const kept = op.row.cells.some((c) => c.blocks.some((b) => b.id === p.blockId));\n          return kept || !fallback ? p : { blockId: fallback.id, offset: 0 };\n        },\n        dirtyBlockIds: [op.tableId],\n      };\n    }\n\n    case \"insertTableRow\": {\n      const { where, bi, block } = mustTable(doc, op.tableId);\n      const rows = block.rows.slice();\n      rows.splice(op.rowIndex, 0, op.row);\n      return {\n        doc: replaceTable(doc, where, bi, { ...block, rows }),\n        inverse: { type: \"removeTableRow\", tableId: op.tableId, rowIndex: op.rowIndex },\n        mapPosition: identity,\n        dirtyBlockIds: [op.tableId],\n      };\n    }\n\n    case \"removeTableRow\": {\n      const { where, bi, block } = mustTable(doc, op.tableId);\n      const removed = block.rows[op.rowIndex];\n      if (!removed) throw new Error(\"removeTableRow: no such row\");\n      const rows = block.rows.slice();\n      rows.splice(op.rowIndex, 1);\n      const removedIds = new Set(removed.cells.flatMap((c) => c.blocks.map((p) => p.id)));\n      const fallbackRow = rows[Math.min(op.rowIndex, rows.length - 1)];\n      const fallback = fallbackRow ? firstParagraphInRows([fallbackRow]) : undefined;\n      return {\n        doc: replaceTable(doc, where, bi, { ...block, rows }),\n        inverse: { type: \"insertTableRow\", tableId: op.tableId, rowIndex: op.rowIndex, row: removed },\n        mapPosition: (p) =>\n          removedIds.has(p.blockId) && fallback ? { blockId: fallback.id, offset: 0 } : p,\n        dirtyBlockIds: [op.tableId],\n      };\n    }\n\n    case \"setListDefinition\": {\n      const old = doc.lists?.[op.listId] ?? null;\n      const lists = { ...(doc.lists ?? {}) };\n      if (op.def) lists[op.listId] = op.def;\n      else delete lists[op.listId];\n      return {\n        doc: { ...doc, lists },\n        inverse: { type: \"setListDefinition\", listId: op.listId, def: old },\n        mapPosition: identity,\n        // Indents come from the definition \u2192 every paragraph in the list must\n        // re-measure; their (revision,width) line-cache keys change with width.\n        dirtyBlockIds: [],\n      };\n    }\n\n    case \"setTableStructure\": {\n      const { where, bi, block } = mustTable(doc, op.tableId);\n      const oldIds = new Set(\n        block.rows.flatMap((r) => r.cells.flatMap((c) => c.blocks.map((p) => p.id))),\n      );\n      const fallback = firstParagraphInRows(op.rows);\n      const next: TableBlock = { ...block, rows: op.rows };\n      if (op.colFractions) next.colFractions = op.colFractions;\n      else delete next.colFractions;\n      const inverse: Op = { type: \"setTableStructure\", tableId: op.tableId, rows: block.rows };\n      if (block.colFractions) inverse.colFractions = block.colFractions;\n      return {\n        doc: replaceTable(doc, where, bi, next),\n        inverse,\n        mapPosition: (p) => {\n          if (!oldIds.has(p.blockId)) return p;\n          const kept = op.rows.some((r) =>\n            r.cells.some((c) => c.blocks.some((b) => b.id === p.blockId)),\n          );\n          return kept || !fallback ? p : { blockId: fallback.id, offset: 0 };\n        },\n        dirtyBlockIds: [op.tableId],\n      };\n    }\n\n    case \"insertTableColumn\": {\n      const { where, bi, block } = mustTable(doc, op.tableId);\n      const snapshot: Op = { type: \"setTableStructure\", tableId: op.tableId, rows: block.rows };\n      if (block.colFractions) snapshot.colFractions = block.colFractions;\n      // Span-aware: a merged cell covering the insertion point grows by one\n      // column instead of having a new cell slotted into its middle.\n      const rows = block.rows.map((row, ri) => {\n        const cells: TableCell[] = [];\n        let col = 0;\n        let inserted = false;\n        for (const cell of row.cells) {\n          const span = cell.colSpan ?? 1;\n          if (!inserted && op.colIndex > col && op.colIndex < col + span) {\n            cells.push({ ...cell, colSpan: span + 1 });\n            inserted = true;\n          } else if (!inserted && op.colIndex === col) {\n            const fresh = op.cells[ri];\n            if (fresh) cells.push(fresh);\n            cells.push(cell);\n            inserted = true;\n          } else {\n            cells.push(cell);\n          }\n          col += span;\n        }\n        if (!inserted) {\n          const fresh = op.cells[ri];\n          if (fresh) cells.push(fresh); // append at the right edge\n        }\n        return { cells };\n      });\n      let fractions = op.fractions;\n      if (!fractions) {\n        const old = effectiveFractions(block);\n        const fresh = 1 / (old.length + 1);\n        fractions = old.map((f) => f * (1 - fresh));\n        fractions.splice(op.colIndex, 0, fresh);\n      }\n      return {\n        doc: replaceTable(doc, where, bi, { ...block, rows, colFractions: fractions }),\n        inverse: snapshot,\n        mapPosition: identity,\n        dirtyBlockIds: [op.tableId],\n      };\n    }\n\n    case \"setStylesheet\": {\n      const old = doc.stylesheet ?? { styles: [], defaultStyleId: \"Normal\" };\n      return {\n        doc: { ...doc, stylesheet: op.stylesheet },\n        inverse: { type: \"setStylesheet\", stylesheet: old },\n        mapPosition: identity,\n        dirtyBlockIds: [], // restyling paragraphs happens via setRuns/setParaStyle ops\n      };\n    }\n\n    case \"setTableStyleSheet\": {\n      const old = doc.tableStyles ?? {};\n      return {\n        doc: { ...doc, tableStyles: op.tableStyles },\n        inverse: { type: \"setTableStyleSheet\", tableStyles: old },\n        mapPosition: identity,\n        dirtyBlockIds: [], // re-baking cells happens via the table-replace ops\n      };\n    }\n\n    case \"setTableStyleRef\": {\n      const { where, bi, block } = mustTable(doc, op.tableId);\n      const oldStyleId = block.styleId ?? null;\n      const oldCond = block.condOverrides ?? null;\n      const next: TableBlock = { ...block };\n      if (op.styleId === null) delete next.styleId;\n      else next.styleId = op.styleId;\n      if (op.condOverrides !== undefined) {\n        if (op.condOverrides === null) delete next.condOverrides;\n        else next.condOverrides = op.condOverrides;\n      }\n      return {\n        doc: replaceTable(doc, where, bi, next),\n        inverse: { type: \"setTableStyleRef\", tableId: op.tableId, styleId: oldStyleId, condOverrides: oldCond },\n        mapPosition: identity,\n        dirtyBlockIds: [op.tableId],\n      };\n    }\n\n    case \"setSectionProps\": {\n      const s = doc.section;\n      const old: SectionGeometry = {\n        pageWidthPx: s.pageWidthPx,\n        pageHeightPx: s.pageHeightPx,\n        marginPx: { ...s.marginPx },\n        columns: s.columns\n          ? { ...s.columns, ...(s.columns.cols ? { cols: s.columns.cols.map((c) => ({ ...c })) } : {}) }\n          : null,\n        pageNumberStart: s.pageNumberStart ?? null,\n        headerDistancePx: s.headerDistancePx ?? null,\n        footerDistancePx: s.footerDistancePx ?? null,\n        pageColorHex: s.pageColorHex ?? null,\n        pageBorders: s.pageBorders ?? null,\n      };\n      const next = {\n        ...s,\n        pageWidthPx: op.geometry.pageWidthPx,\n        pageHeightPx: op.geometry.pageHeightPx,\n        marginPx: op.geometry.marginPx,\n      };\n      if (op.geometry.columns) next.columns = op.geometry.columns;\n      else delete next.columns;\n      if (op.geometry.pageNumberStart !== null) next.pageNumberStart = op.geometry.pageNumberStart;\n      else delete next.pageNumberStart;\n      if (op.geometry.headerDistancePx !== null) next.headerDistancePx = op.geometry.headerDistancePx;\n      else delete next.headerDistancePx;\n      if (op.geometry.footerDistancePx !== null) next.footerDistancePx = op.geometry.footerDistancePx;\n      else delete next.footerDistancePx;\n      if (op.geometry.pageColorHex !== null) next.pageColorHex = op.geometry.pageColorHex;\n      else delete next.pageColorHex;\n      if (op.geometry.pageBorders !== null) next.pageBorders = op.geometry.pageBorders;\n      else delete next.pageBorders;\n      return {\n        doc: { ...doc, section: next },\n        inverse: { type: \"setSectionProps\", geometry: old },\n        mapPosition: identity,\n        dirtyBlockIds: [], // geometry change \u2192 full re-walk; line caches keyed by width\n      };\n    }\n\n    case \"setFootnote\": {\n      const old = doc.footnotes?.[op.noteId] ?? null;\n      const footnotes = { ...(doc.footnotes ?? {}) };\n      if (op.paras) footnotes[op.noteId] = op.paras;\n      else delete footnotes[op.noteId];\n      const removedIds = new Set((old ?? []).map((p) => p.id));\n      const fallback = doc.blocks.find((b) => b.kind === \"paragraph\");\n      return {\n        doc: { ...doc, footnotes },\n        inverse: { type: \"setFootnote\", noteId: op.noteId, paras: old },\n        mapPosition: (p) => {\n          if (!removedIds.has(p.blockId)) return p;\n          const kept = (op.paras ?? []).some((b) => b.id === p.blockId);\n          return kept || !fallback ? p : { blockId: fallback.id, offset: 0 };\n        },\n        dirtyBlockIds: [],\n      };\n    }\n\n    case \"setSdtProps\": {\n      const old = doc.sdts?.[op.id] ?? null;\n      const sdts = { ...(doc.sdts ?? {}) };\n      if (op.props) sdts[op.id] = op.props;\n      else delete sdts[op.id];\n      return {\n        doc: { ...doc, sdts },\n        inverse: { type: \"setSdtProps\", id: op.id, props: old },\n        mapPosition: identity,\n        dirtyBlockIds: [], // run markers change via setRuns/applyStylePatch ops\n      };\n    }\n\n    case \"setField\": {\n      const old = doc.fields?.[op.id] ?? null;\n      const fields = { ...(doc.fields ?? {}) };\n      if (op.def) fields[op.id] = op.def;\n      else delete fields[op.id];\n      return {\n        doc: { ...doc, fields },\n        inverse: { type: \"setField\", id: op.id, def: old },\n        mapPosition: identity,\n        dirtyBlockIds: [], // run/block fieldId markers change via setRuns/insert ops\n      };\n    }\n\n    case \"setTocInstruction\": {\n      const old = doc.tocInstruction ?? null;\n      const next = { ...doc };\n      if (op.instruction !== null) next.tocInstruction = op.instruction;\n      else delete next.tocInstruction;\n      return {\n        doc: next,\n        inverse: { type: \"setTocInstruction\", instruction: old },\n        mapPosition: identity,\n        dirtyBlockIds: [], // entries are regenerated via insert/removeBlock ops in the same tx\n      };\n    }\n\n    case \"setBookmark\": {\n      const old = doc.bookmarks?.[op.name] ?? null;\n      const bookmarks = { ...(doc.bookmarks ?? {}) };\n      if (op.range) bookmarks[op.name] = op.range;\n      else delete bookmarks[op.name];\n      return {\n        doc: { ...doc, bookmarks },\n        inverse: { type: \"setBookmark\", name: op.name, range: old },\n        mapPosition: identity,\n        dirtyBlockIds: [],\n      };\n    }\n\n    case \"setSectionBand\": {\n      const old = doc.section[op.band] ?? null;\n      const section = { ...doc.section };\n      if (op.blocks) section[op.band] = op.blocks;\n      else delete section[op.band];\n      const removedIds = new Set(\n        (old ?? []).filter((b) => b.kind === \"paragraph\").map((b) => b.id),\n      );\n      const fallback = doc.blocks.find((b) => b.kind === \"paragraph\");\n      return {\n        doc: { ...doc, section },\n        inverse: { type: \"setSectionBand\", band: op.band, blocks: old },\n        mapPosition: (p) => {\n          if (!removedIds.has(p.blockId)) return p;\n          const kept = (op.blocks ?? []).some((b) => b.id === p.blockId);\n          return kept || !fallback ? p : { blockId: fallback.id, offset: 0 };\n        },\n        dirtyBlockIds: [],\n      };\n    }\n\n    case \"removeTableColumn\": {\n      const { where, bi, block } = mustTable(doc, op.tableId);\n      const snapshot: Op = { type: \"setTableStructure\", tableId: op.tableId, rows: block.rows };\n      if (block.colFractions) snapshot.colFractions = block.colFractions;\n      const oldFractions = effectiveFractions(block);\n      const removedIds = new Set<string>();\n      // Span-aware: a merged cell covering the removed column shrinks; an\n      // unmerged cell at that column is dropped.\n      const rows = block.rows.map((row) => {\n        const cells: TableCell[] = [];\n        let col = 0;\n        for (const cell of row.cells) {\n          const span = cell.colSpan ?? 1;\n          if (op.colIndex >= col && op.colIndex < col + span) {\n            if (span > 1) {\n              const shrunk: TableCell = { ...cell };\n              if (span - 1 > 1) shrunk.colSpan = span - 1;\n              else delete shrunk.colSpan;\n              cells.push(shrunk);\n            } else {\n              for (const p of cell.blocks) removedIds.add(p.id);\n            }\n          } else {\n            cells.push(cell);\n          }\n          col += span;\n        }\n        return { cells };\n      });\n      const rest = oldFractions.filter((_, i) => i !== op.colIndex);\n      const sum = rest.reduce((s, f) => s + f, 0) || 1;\n      const fractions = rest.map((f) => f / sum);\n      const fallback = firstParagraphInRows(rows);\n      return {\n        doc: replaceTable(doc, where, bi, { ...block, rows, colFractions: fractions }),\n        inverse: snapshot,\n        mapPosition: (p) =>\n          removedIds.has(p.blockId) && fallback ? { blockId: fallback.id, offset: 0 } : p,\n        dirtyBlockIds: [op.tableId],\n      };\n    }\n  }\n}\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 { 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\nconst TOC_BASE_CHAR: CharStyle = {\r\n  fontFamily: \"Georgia, serif\", fontSizePx: 13, bold: false, italic: false,\r\n  underline: false, strikethrough: false, color: \"#202124\",\r\n};\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 ?? 20;\r\n  const leader = opts.leader ?? \"dot\";\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      align: \"left\", lineHeight: 1.5, spaceBeforePx: 0, spaceAfterPx: 2, indentFirstLinePx: 0,\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      align: \"left\", lineHeight: 1.5, spaceBeforePx: 0, spaceAfterPx: 2,\r\n      indentFirstLinePx: 0, 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 { 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\nexport function defaultStylesheet(): Stylesheet {\n  const base: Partial<ParaStyle> = { lineHeight: 1.5, spaceBeforePx: 0, spaceAfterPx: 12 };\n  return {\n    defaultStyleId: \"Normal\",\n    styles: [\n      {\n        id: \"Normal\",\n        name: \"Normal\",\n        char: { fontFamily: \"Georgia, serif\", fontSizePx: 16, bold: false, italic: false, color: \"#202124\" },\n        para: { ...base, align: \"left\", indentFirstLinePx: 0 },\n      },\n      {\n        id: \"Title\",\n        name: \"Title\",\n        basedOn: \"Normal\",\n        char: { fontFamily: \"Arial, sans-serif\", 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: \"Arial, sans-serif\", 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", "// 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": []
-}

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

@@ -1,7 +0,0 @@
-{
-  "version": 3,
-  "sources": ["../src/fonts/clones.ts", "../src/paint/paintStyle.ts", "../src/layout/metrics.ts"],
-  "sourcesContent": ["// Single source of truth for font substitution. The editor and both exporters\n// render & measure with these freely-redistributable metric clones instead of\n// the (Windows-only) originals, so layout is identical across the editor, the\n// browser export, and the Node backend \u2014 no system fonts anywhere. The model\n// keeps the original family names; only rendering/measuring/embedding map to a\n// clone. See src/export/shared/fonts/LICENSES.md.\n\n// \"TimesNewRoman\" is the genuine Microsoft Times New Roman (bundled at the user's\n// request), not a clone \u2014 see FONTS.md / fonts/LICENSES.md for the licensing note.\nexport const CLONE_FAMILIES = [\"Carlito\", \"Caladea\", \"Gelasio\", \"Arimo\", \"TimesNewRoman\", \"Cousine\"] as const;\nexport const FALLBACK_CLONE = \"Arimo\";\n\n// Requested family (lowercased, first CSS-stack token) -> bundled clone family.\n// Includes identity entries for the clone names themselves (so already-mapped\n// strings resolve to themselves) and the generic CSS families.\nexport const CLONE_OF: Record<string, string> = {\n  // metric clones of common Office/Windows fonts\n  calibri: \"Carlito\",\n  cambria: \"Caladea\",\n  georgia: \"Gelasio\",\n  arial: \"Arimo\",\n  helvetica: \"Arimo\",\n  \"helvetica neue\": \"Arimo\",\n  \"times new roman\": \"TimesNewRoman\",\n  times: \"TimesNewRoman\",\n  \"courier new\": \"Cousine\",\n  courier: \"Cousine\",\n  // reasonable substitutes for fonts we don't ship\n  verdana: \"Arimo\",\n  tahoma: \"Arimo\",\n  \"segoe ui\": \"Arimo\",\n  \"trebuchet ms\": \"Arimo\",\n  consolas: \"Cousine\",\n  monaco: \"Cousine\",\n  \"lucida console\": \"Cousine\",\n  garamond: \"TimesNewRoman\",\n  \"book antiqua\": \"Caladea\",\n  palatino: \"Caladea\",\n  // generic CSS families\n  serif: \"TimesNewRoman\",\n  \"sans-serif\": \"Arimo\",\n  sans: \"Arimo\",\n  monospace: \"Cousine\",\n  mono: \"Cousine\",\n  // identity (already a clone)\n  carlito: \"Carlito\",\n  caladea: \"Caladea\",\n  gelasio: \"Gelasio\",\n  arimo: \"Arimo\",\n  timesnewroman: \"TimesNewRoman\",\n  cousine: \"Cousine\",\n};\n\n// Per-clone vertical metrics as a fraction of font size (ascent, descent above/\n// below the baseline). Used by fontMetrics so line heights are computed the SAME\n// way in the editor and both exporters \u2014 otherwise the browser's canvas\n// fontBoundingBox (editor) and fontkit's tables (export) disagree by a hair and\n// pagination drifts by a page. Values measured from the browser's canvas\n// fontBoundingBox at 16px (an exact multiple here), so the editor's appearance is\n// unchanged while the export now matches it on every platform.\nexport const CLONE_METRICS: Record<string, { ascent: number; descent: number }> = {\n  Carlito: { ascent: 0.9375, descent: 0.25 },\n  Caladea: { ascent: 0.9375, descent: 0.25 },\n  Gelasio: { ascent: 0.9375, descent: 0.3125 },\n  Arimo: { ascent: 0.875, descent: 0.1875 },\n  TimesNewRoman: { ascent: 0.875, descent: 0.1875 },\n  Cousine: { ascent: 0.625, descent: 0.1875 },\n};\n\n/** Resolve one CSS-stack family token to its bundled clone family. */\nexport function cloneFamilyFor(family: string): { clone: string; substituted: boolean } {\n  const key = family.trim().toLowerCase().replace(/^[\"']|[\"']$/g, \"\");\n  const clone = CLONE_OF[key];\n  return clone ? { clone, substituted: false } : { clone: FALLBACK_CLONE, substituted: true };\n}\n\n/** First token of a CSS font-family stack (\"Calibri, serif\" -> \"Calibri\"). */\nexport const firstFamilyToken = (stack: string): string => (stack.split(\",\")[0] ?? \"\").trim();\n\nexport const FONT_STYLES = [\"Regular\", \"Bold\", \"Italic\", \"BoldItalic\"] as const;\n\n/** Every bundled face filename. */\nexport const FONT_FILES: string[] = CLONE_FAMILIES.flatMap((fam) =>\n  FONT_STYLES.map((style) => `${fam}-${style}.ttf`),\n);\n\n/** Toolbar font list: value is the original family (stored in the model), label\n *  shows the clone we actually render \u2014 e.g. \"Calibri (Carlito)\". */\nexport const TOOLBAR_FONTS: { value: string; label: string }[] = [\n  { value: \"Calibri, sans-serif\", label: \"Calibri (Carlito)\" },\n  { value: \"Cambria, serif\", label: \"Cambria (Caladea)\" },\n  { value: \"Georgia, serif\", label: \"Georgia (Gelasio)\" },\n  { value: \"Arial, sans-serif\", label: \"Arial (Arimo)\" },\n  { value: \"Times New Roman, serif\", label: \"Times New Roman\" },\n  { value: \"Verdana, sans-serif\", label: \"Verdana (Arimo)\" },\n  { value: \"Consolas, monospace\", label: \"Consolas (Cousine)\" },\n  { value: \"Courier New, monospace\", label: \"Courier New (Cousine)\" },\n];\n", "// Shared paint styling \u2014 the constants and per-run styling DECISIONS that the\n// canvas renderer (src/paint/renderer.ts) and the PDF painter\n// (src/export/pdf/paintBlock.ts) must keep in lockstep. Centralising the magic\n// numbers and the link/colour rules stops the two painters from silently\n// drifting; the actual draw calls stay separate (canvas vs pdfkit are different\n// APIs). Pure data + math \u2014 no DOM, no rendering backend.\n\nimport type { CharStyle, PageBorderEdge, PageBorders, TabLeader } from \"@cw/shared\";\n\n// --- colours ---------------------------------------------------------------\n/** Unstyled/native table grid (when a cell carries no explicit borders). */\nexport const DEFAULT_GRID_COLOR = \"#c0c4c9\";\n/** External hyperlinks paint in this blue (Word's affordance). */\nexport const EXTERNAL_LINK_COLOR = \"#0b57d0\";\n/** In-document anchors that inherited a Hyperlink blue read as plain text. */\nexport const ANCHOR_TEXT_COLOR = \"#202124\";\nexport const FOOTNOTE_RULE_COLOR = \"#80868b\";\n/** Non-printing formatting marks (space dots, tab arrows, pilcrows, line breaks)\n *  drawn only when \"show formatting marks\" is on. A muted gray-blue, like Word. */\nexport const FORMATTING_MARK_COLOR = \"#7a8aa0\";\nexport const TOC_LEADER_COLOR = \"#9aa0a6\";\nexport const IMAGE_PLACEHOLDER_COLOR = \"#f1f3f4\";\n\n/** Office \"Hyperlink\" character-style blues, normalised to text colour when they\n *  arrive on an in-document anchor (TOC/cross-ref) so those read as plain text. */\nexport const HYPERLINK_BLUES = new Set([\n  \"#0563c1\", \"#0000ff\", \"#0000ee\", \"#0b57d0\", \"#0066cc\", \"#1155cc\",\n]);\n\n/** A leader/TOC colour that inherited a Hyperlink blue \u2192 text colour. */\nexport const normalizeLinkBlue = (color: string): string =>\n  HYPERLINK_BLUES.has(color.toLowerCase()) ? ANCHOR_TEXT_COLOR : color;\n\n// --- sub/superscript -------------------------------------------------------\n/** Sub/superscript is MEASURED and PAINTED at this fraction of the run size\n *  (metrics.charStyleToFont scales the font; the painters scale to match). */\nexport const SUB_SUPER_SCALE = 0.65;\nconst SUPER_SHIFT = -0.38;\nconst SUB_SHIFT = 0.16;\n\n/** Baseline shift (px) for a sub/superscript run \u2014 fraction of the ORIGINAL size. */\nexport function verticalShift(vertical: CharStyle[\"verticalAlign\"], fontSizePx: number): number {\n  if (vertical === \"super\") return SUPER_SHIFT * fontSizePx;\n  if (vertical === \"sub\") return SUB_SHIFT * fontSizePx;\n  return 0;\n}\n\n// --- text decorations ------------------------------------------------------\n/** Underline / strikethrough thickness (px). */\nexport const decorationThickness = (fontSizePx: number): number => Math.max(1, fontSizePx / 14);\n/** Underline distance below the baseline (the run's vShift is added by the caller). */\nexport const UNDERLINE_OFFSET_PX = 1.5;\n/** Strikethrough offset relative to the baseline (above it). */\nexport const strikeOffset = (fontSizePx: number): number => -0.28 * fontSizePx;\n\n/** The colour + decoration decision for a run, with link normalisation applied. */\nexport interface RunPaint {\n  color: string;\n  underline: boolean;\n  strike: boolean;\n  /** External (non-anchor) link \u2014 paints blue+underlined; the PDF also annotates it. */\n  externalLink: boolean;\n}\nexport function runPaint(style: CharStyle): RunPaint {\n  const anchor = style.link !== undefined && style.link.startsWith(\"#\");\n  const externalLink = style.link !== undefined && !anchor;\n  let color = style.color;\n  if (externalLink) color = EXTERNAL_LINK_COLOR;\n  else if (anchor && HYPERLINK_BLUES.has(style.color.toLowerCase())) color = ANCHOR_TEXT_COLOR;\n  return {\n    color,\n    underline: externalLink || (!!style.underline && !anchor),\n    strike: !!style.strikethrough,\n    externalLink,\n  };\n}\n\n// --- leaders (tab + TOC) ---------------------------------------------------\n/** Tab-leader dash pattern; [] = solid (underscore/none). */\nexport function leaderDash(kind: TabLeader): number[] {\n  return kind === \"dot\" ? [1, 3] : kind === \"dash\" ? [4, 3] : [];\n}\nexport const leaderWidth = (fontSizePx: number): number => Math.max(1, fontSizePx / 14);\nexport const TOC_LEADER_DASH: number[] = [1, 4];\n/** Gap (px) between an entry's text/number and its dot leader. */\nexport const TOC_LEADER_GAP_PX = 8;\n\n// --- footnote rule ---------------------------------------------------------\n/** The separator rule spans this fraction of the content width (Word style). */\nexport const FOOTNOTE_RULE_WIDTH_FRACTION = 1 / 3;\n\n// --- column separators -----------------------------------------------------\n/** Thin gray rule drawn between newspaper columns (w:cols/@w:sep). */\nexport const COLUMN_SEPARATOR_COLOR = \"#c0c4c9\";\n\n// --- page borders (w:pgBorders) --------------------------------------------\n/** Default offset (px) of a page border from the page edge / text when an edge\n *  omits w:space. ~24pt is Word's typical page-border offset. */\nconst PAGE_BORDER_DEFAULT_SPACE = 24;\n\n/** One stroked line segment of a page border, in page (px) coords. */\nexport interface PageBorderSegment {\n  x1: number;\n  y1: number;\n  x2: number;\n  y2: number;\n  widthPx: number;\n  color: string;\n  /** [] = solid. */\n  dash: number[];\n}\n\n/** Geometry of a page border box \u2192 the line segments to stroke. Shared so the\n *  canvas renderer and the PDF painter draw identical borders. \"double\" yields\n *  two parallel segments; \"none\"/absent edges are skipped. */\nexport function pageBorderSegments(\n  borders: PageBorders,\n  pageW: number,\n  pageH: number,\n  margin: { top: number; right: number; bottom: number; left: number },\n): PageBorderSegment[] {\n  const fromText = borders.offsetFrom === \"text\";\n  const sp = (e?: PageBorderEdge): number => e?.spacePx ?? PAGE_BORDER_DEFAULT_SPACE;\n  // Each edge's distance, then the box bounds (per-edge space; usually uniform).\n  const xL = fromText ? margin.left - sp(borders.left) : sp(borders.left);\n  const xR = fromText ? pageW - margin.right + sp(borders.right) : pageW - sp(borders.right);\n  const yT = fromText ? margin.top - sp(borders.top) : sp(borders.top);\n  const yB = fromText ? pageH - margin.bottom + sp(borders.bottom) : pageH - sp(borders.bottom);\n  const out: PageBorderSegment[] = [];\n  const push = (e: PageBorderEdge | undefined, x1: number, y1: number, x2: number, y2: number): void => {\n    if (!e || e.style === \"none\") return;\n    const w = e.style === \"thick\" ? Math.max(2, e.widthPx) : Math.max(0.5, e.widthPx);\n    const color = e.color === \"auto\" ? \"#000000\" : e.color;\n    const dash = e.style === \"dashed\" ? [w * 3, w * 2] : e.style === \"dotted\" ? [w, w * 1.5] : [];\n    out.push({ x1, y1, x2, y2, widthPx: w, color, dash });\n    if (e.style === \"double\") {\n      const g = w + 1; // inset the second line toward the box interior\n      const horizontal = y1 === y2;\n      if (horizontal) {\n        const dy = y1 < pageH / 2 ? g : -g;\n        out.push({ x1, y1: y1 + dy, x2, y2: y2 + dy, widthPx: w, color, dash: [] });\n      } else {\n        const dx = x1 < pageW / 2 ? g : -g;\n        out.push({ x1: x1 + dx, y1, x2: x2 + dx, y2, widthPx: w, color, dash: [] });\n      }\n    }\n  };\n  push(borders.top, xL, yT, xR, yT);\n  push(borders.bottom, xL, yB, xR, yB);\n  push(borders.left, xL, yT, xL, yB);\n  push(borders.right, xR, yT, xR, yB);\n  return out;\n}\n\n// --- cell borders ----------------------------------------------------------\n/** Hairlines clamp up so a thin rule stays visible. */\nexport const cellBorderWidth = (widthPx: number): number => Math.max(0.5, widthPx);\n/** Dash pattern for a cell edge of stroke width w; [] = solid. */\nexport function cellBorderDash(style: string | undefined, w: number): number[] {\n  return style === \"dashed\" ? [w * 3, w * 2] : style === \"dotted\" ? [w, w * 1.5] : [];\n}\n/** Offset of the inner stroke of a \"double\" border. */\nexport const doubleBorderGap = (w: number): number => w + 1;\n", "// Vertical font metrics (pretext measures widths; ascent/descent are ours).\n// One hidden canvas, results cached per font string.\n\nimport type { CharStyle } from \"@cw/shared\";\nimport { CLONE_METRICS, cloneFamilyFor, firstFamilyToken } from \"../fonts/clones\";\nimport { SUB_SUPER_SCALE } from \"../paint/paintStyle\";\n\nexport interface FontMetrics {\n  ascent: number;\n  descent: number;\n}\n\n/** The slice of CanvasRenderingContext2D the layout actually measures through.\n *  DOM-free hosts (the export worker, Node backends) inject their own via\n *  {@link setMeasureContext}; the browser falls back to a real canvas. */\nexport interface MeasureContext {\n  font: string;\n  measureText(text: string): {\n    width: number;\n    fontBoundingBoxAscent: number;\n    fontBoundingBoxDescent: number;\n  };\n}\n\nlet injectedCtx: MeasureContext | null = null;\nlet browserCtx: MeasureContext | null = null;\n\n/** Install a measurement context (export/Node hosts). Must be called before the\n *  engine measures any text. No-op for the browser, which uses a real canvas. */\nexport function setMeasureContext(ctx: MeasureContext): void {\n  injectedCtx = ctx;\n}\n\n// Lazily created so importing this module never touches the DOM \u2014 the engine can\n// run under Node once a context is injected (browser path stays byte-identical).\nfunction measureContext(): MeasureContext {\n  if (injectedCtx) return injectedCtx;\n  if (!browserCtx) {\n    browserCtx = document.createElement(\"canvas\").getContext(\"2d\")! as unknown as MeasureContext;\n  }\n  return browserCtx;\n}\n\nconst metricsCache = new Map<string, FontMetrics>();\n\nexport function charStyleToFont(s: CharStyle): string {\n  const italic = s.italic ? \"italic \" : \"\";\n  const weight = s.bold ? \"700\" : \"400\";\n  // Sub/superscript runs are MEASURED at the scaled size (paint shifts the\n  // baseline) \u2014 pretext must measure exactly what paint draws.\n  const size = s.verticalAlign ? Math.round(s.fontSizePx * SUB_SUPER_SCALE) : s.fontSizePx;\n  // Render & measure with the bundled metric clone (e.g. Calibri -> Carlito), so\n  // the editor, the browser export, and the Node backend all lay out identically\n  // \u2014 no dependency on system fonts. The model keeps the original family.\n  const family = cloneFamilyFor(firstFamilyToken(s.fontFamily)).clone;\n  return `${italic}${weight} ${size}px ${family}`;\n}\n\n/** One-off text width at a font \u2014 LAYOUT-time only (paint never measures).\n *  Used for paint-only decorations the engine positions (TOC page numbers). */\nexport function measureTextWidth(text: string, font: string): number {\n  const ctx = measureContext();\n  ctx.font = font;\n  return ctx.measureText(text).width;\n}\n\n// Vertical metrics come from baked per-clone ratios (NOT the canvas/fontkit\n// context), so the editor and the exporters compute identical line heights and\n// therefore identical pagination on every platform. charStyleToFont already\n// emits the clone family, so the last token of the font string is it.\nexport function fontMetrics(font: string): FontMetrics {\n  let m = metricsCache.get(font);\n  if (!m) {\n    const sizeMatch = /(\\d+(?:\\.\\d+)?)px/.exec(font);\n    const size = sizeMatch ? parseFloat(sizeMatch[1]!) : 16;\n    const family = font.slice(font.indexOf(\"px \") + 3).trim();\n    const r = CLONE_METRICS[cloneFamilyFor(family).clone] ?? { ascent: 0.9, descent: 0.25 };\n    m = { ascent: Math.round(r.ascent * size), descent: Math.round(r.descent * size) };\n    metricsCache.set(font, m);\n  }\n  return m;\n}\n"],
-  "mappings": ";;;;;;;;AASO,IAAM,iBAAiB,CAAC,WAAW,WAAW,WAAW,SAAS,iBAAiB,SAAS;AAC5F,IAAM,iBAAiB;AAKvB,IAAM,WAAmC;AAAA;AAAA,EAE9C,SAAS;AAAA,EACT,SAAS;AAAA,EACT,SAAS;AAAA,EACT,OAAO;AAAA,EACP,WAAW;AAAA,EACX,kBAAkB;AAAA,EAClB,mBAAmB;AAAA,EACnB,OAAO;AAAA,EACP,eAAe;AAAA,EACf,SAAS;AAAA;AAAA,EAET,SAAS;AAAA,EACT,QAAQ;AAAA,EACR,YAAY;AAAA,EACZ,gBAAgB;AAAA,EAChB,UAAU;AAAA,EACV,QAAQ;AAAA,EACR,kBAAkB;AAAA,EAClB,UAAU;AAAA,EACV,gBAAgB;AAAA,EAChB,UAAU;AAAA;AAAA,EAEV,OAAO;AAAA,EACP,cAAc;AAAA,EACd,MAAM;AAAA,EACN,WAAW;AAAA,EACX,MAAM;AAAA;AAAA,EAEN,SAAS;AAAA,EACT,SAAS;AAAA,EACT,SAAS;AAAA,EACT,OAAO;AAAA,EACP,eAAe;AAAA,EACf,SAAS;AACX;AASO,IAAM,gBAAqE;AAAA,EAChF,SAAS,EAAE,QAAQ,QAAQ,SAAS,KAAK;AAAA,EACzC,SAAS,EAAE,QAAQ,QAAQ,SAAS,KAAK;AAAA,EACzC,SAAS,EAAE,QAAQ,QAAQ,SAAS,OAAO;AAAA,EAC3C,OAAO,EAAE,QAAQ,OAAO,SAAS,OAAO;AAAA,EACxC,eAAe,EAAE,QAAQ,OAAO,SAAS,OAAO;AAAA,EAChD,SAAS,EAAE,QAAQ,OAAO,SAAS,OAAO;AAC5C;AAGO,SAAS,eAAe,QAAyD;AACtF,QAAM,MAAM,OAAO,KAAK,EAAE,YAAY,EAAE,QAAQ,gBAAgB,EAAE;AAClE,QAAM,QAAQ,SAAS,GAAG;AAC1B,SAAO,QAAQ,EAAE,OAAO,aAAa,MAAM,IAAI,EAAE,OAAO,gBAAgB,aAAa,KAAK;AAC5F;AAGO,IAAM,mBAAmB,CAAC,WAA2B,MAAM,MAAM,GAAG,EAAE,CAAC,KAAK,IAAI,KAAK;AAErF,IAAM,cAAc,CAAC,WAAW,QAAQ,UAAU,YAAY;AAG9D,IAAM,aAAuB,eAAe;AAAA,EAAQ,CAAC,QAC1D,YAAY,IAAI,CAAC,UAAU,GAAG,GAAG,IAAI,KAAK,MAAM;AAClD;;;ACzEO,IAAM,qBAAqB;AAE3B,IAAM,sBAAsB;AAE5B,IAAM,oBAAoB;AAC1B,IAAM,sBAAsB;AAI5B,IAAM,mBAAmB;AACzB,IAAM,0BAA0B;AAIhC,IAAM,kBAAkB,oBAAI,IAAI;AAAA,EACrC;AAAA,EAAW;AAAA,EAAW;AAAA,EAAW;AAAA,EAAW;AAAA,EAAW;AACzD,CAAC;AAGM,IAAM,oBAAoB,CAAC,UAChC,gBAAgB,IAAI,MAAM,YAAY,CAAC,IAAI,oBAAoB;AAK1D,IAAM,kBAAkB;AAC/B,IAAM,cAAc;AACpB,IAAM,YAAY;AAGX,SAAS,cAAc,UAAsC,YAA4B;AAC9F,MAAI,aAAa,QAAS,QAAO,cAAc;AAC/C,MAAI,aAAa,MAAO,QAAO,YAAY;AAC3C,SAAO;AACT;AAIO,IAAM,sBAAsB,CAAC,eAA+B,KAAK,IAAI,GAAG,aAAa,EAAE;AAEvF,IAAM,sBAAsB;AAE5B,IAAM,eAAe,CAAC,eAA+B,QAAQ;AAU7D,SAAS,SAAS,OAA4B;AACnD,QAAM,SAAS,MAAM,SAAS,UAAa,MAAM,KAAK,WAAW,GAAG;AACpE,QAAM,eAAe,MAAM,SAAS,UAAa,CAAC;AAClD,MAAI,QAAQ,MAAM;AAClB,MAAI,aAAc,SAAQ;AAAA,WACjB,UAAU,gBAAgB,IAAI,MAAM,MAAM,YAAY,CAAC,EAAG,SAAQ;AAC3E,SAAO;AAAA,IACL;AAAA,IACA,WAAW,gBAAiB,CAAC,CAAC,MAAM,aAAa,CAAC;AAAA,IAClD,QAAQ,CAAC,CAAC,MAAM;AAAA,IAChB;AAAA,EACF;AACF;AAIO,SAAS,WAAW,MAA2B;AACpD,SAAO,SAAS,QAAQ,CAAC,GAAG,CAAC,IAAI,SAAS,SAAS,CAAC,GAAG,CAAC,IAAI,CAAC;AAC/D;AACO,IAAM,cAAc,CAAC,eAA+B,KAAK,IAAI,GAAG,aAAa,EAAE;AAC/E,IAAM,kBAA4B,CAAC,GAAG,CAAC;AAEvC,IAAM,oBAAoB;AAI1B,IAAM,+BAA+B,IAAI;AAIzC,IAAM,yBAAyB;AAKtC,IAAM,4BAA4B;AAiB3B,SAAS,mBACd,SACA,OACA,OACA,QACqB;AACrB,QAAM,WAAW,QAAQ,eAAe;AACxC,QAAM,KAAK,CAAC,MAA+B,GAAG,WAAW;AAEzD,QAAM,KAAK,WAAW,OAAO,OAAO,GAAG,QAAQ,IAAI,IAAI,GAAG,QAAQ,IAAI;AACtE,QAAM,KAAK,WAAW,QAAQ,OAAO,QAAQ,GAAG,QAAQ,KAAK,IAAI,QAAQ,GAAG,QAAQ,KAAK;AACzF,QAAM,KAAK,WAAW,OAAO,MAAM,GAAG,QAAQ,GAAG,IAAI,GAAG,QAAQ,GAAG;AACnE,QAAM,KAAK,WAAW,QAAQ,OAAO,SAAS,GAAG,QAAQ,MAAM,IAAI,QAAQ,GAAG,QAAQ,MAAM;AAC5F,QAAM,MAA2B,CAAC;AAClC,QAAM,OAAO,CAAC,GAA+B,IAAY,IAAY,IAAY,OAAqB;AACpG,QAAI,CAAC,KAAK,EAAE,UAAU,OAAQ;AAC9B,UAAM,IAAI,EAAE,UAAU,UAAU,KAAK,IAAI,GAAG,EAAE,OAAO,IAAI,KAAK,IAAI,KAAK,EAAE,OAAO;AAChF,UAAM,QAAQ,EAAE,UAAU,SAAS,YAAY,EAAE;AACjD,UAAM,OAAO,EAAE,UAAU,WAAW,CAAC,IAAI,GAAG,IAAI,CAAC,IAAI,EAAE,UAAU,WAAW,CAAC,GAAG,IAAI,GAAG,IAAI,CAAC;AAC5F,QAAI,KAAK,EAAE,IAAI,IAAI,IAAI,IAAI,SAAS,GAAG,OAAO,KAAK,CAAC;AACpD,QAAI,EAAE,UAAU,UAAU;AACxB,YAAM,IAAI,IAAI;AACd,YAAM,aAAa,OAAO;AAC1B,UAAI,YAAY;AACd,cAAM,KAAK,KAAK,QAAQ,IAAI,IAAI,CAAC;AACjC,YAAI,KAAK,EAAE,IAAI,IAAI,KAAK,IAAI,IAAI,IAAI,KAAK,IAAI,SAAS,GAAG,OAAO,MAAM,CAAC,EAAE,CAAC;AAAA,MAC5E,OAAO;AACL,cAAM,KAAK,KAAK,QAAQ,IAAI,IAAI,CAAC;AACjC,YAAI,KAAK,EAAE,IAAI,KAAK,IAAI,IAAI,IAAI,KAAK,IAAI,IAAI,SAAS,GAAG,OAAO,MAAM,CAAC,EAAE,CAAC;AAAA,MAC5E;AAAA,IACF;AAAA,EACF;AACA,OAAK,QAAQ,KAAK,IAAI,IAAI,IAAI,EAAE;AAChC,OAAK,QAAQ,QAAQ,IAAI,IAAI,IAAI,EAAE;AACnC,OAAK,QAAQ,MAAM,IAAI,IAAI,IAAI,EAAE;AACjC,OAAK,QAAQ,OAAO,IAAI,IAAI,IAAI,EAAE;AAClC,SAAO;AACT;AAIO,IAAM,kBAAkB,CAAC,YAA4B,KAAK,IAAI,KAAK,OAAO;AAE1E,SAAS,eAAe,OAA2B,GAAqB;AAC7E,SAAO,UAAU,WAAW,CAAC,IAAI,GAAG,IAAI,CAAC,IAAI,UAAU,WAAW,CAAC,GAAG,IAAI,GAAG,IAAI,CAAC;AACpF;AAEO,IAAM,kBAAkB,CAAC,MAAsB,IAAI;;;AC1I1D,IAAI,cAAqC;AACzC,IAAI,aAAoC;AAIjC,SAAS,kBAAkB,KAA2B;AAC3D,gBAAc;AAChB;AAIA,SAAS,iBAAiC;AACxC,MAAI,YAAa,QAAO;AACxB,MAAI,CAAC,YAAY;AACf,iBAAa,SAAS,cAAc,QAAQ,EAAE,WAAW,IAAI;AAAA,EAC/D;AACA,SAAO;AACT;AAEA,IAAM,eAAe,oBAAI,IAAyB;AAE3C,SAAS,gBAAgB,GAAsB;AACpD,QAAM,SAAS,EAAE,SAAS,YAAY;AACtC,QAAM,SAAS,EAAE,OAAO,QAAQ;AAGhC,QAAM,OAAO,EAAE,gBAAgB,KAAK,MAAM,EAAE,aAAa,eAAe,IAAI,EAAE;AAI9E,QAAM,SAAS,eAAe,iBAAiB,EAAE,UAAU,CAAC,EAAE;AAC9D,SAAO,GAAG,MAAM,GAAG,MAAM,IAAI,IAAI,MAAM,MAAM;AAC/C;AAIO,SAAS,iBAAiB,MAAc,MAAsB;AACnE,QAAM,MAAM,eAAe;AAC3B,MAAI,OAAO;AACX,SAAO,IAAI,YAAY,IAAI,EAAE;AAC/B;AAMO,SAAS,YAAY,MAA2B;AACrD,MAAI,IAAI,aAAa,IAAI,IAAI;AAC7B,MAAI,CAAC,GAAG;AACN,UAAM,YAAY,oBAAoB,KAAK,IAAI;AAC/C,UAAM,OAAO,YAAY,WAAW,UAAU,CAAC,CAAE,IAAI;AACrD,UAAM,SAAS,KAAK,MAAM,KAAK,QAAQ,KAAK,IAAI,CAAC,EAAE,KAAK;AACxD,UAAM,IAAI,cAAc,eAAe,MAAM,EAAE,KAAK,KAAK,EAAE,QAAQ,KAAK,SAAS,KAAK;AACtF,QAAI,EAAE,QAAQ,KAAK,MAAM,EAAE,SAAS,IAAI,GAAG,SAAS,KAAK,MAAM,EAAE,UAAU,IAAI,EAAE;AACjF,iBAAa,IAAI,MAAM,CAAC;AAAA,EAC1B;AACA,SAAO;AACT;",
-  "names": []
-}