@adeu/core 1.6.2

package/dist/index.cjs

@@ -0,0 +1,3627 @@
+"use strict";
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/index.ts
+var index_exports = {};
+__export(index_exports, {
+  BatchValidationError: () => BatchValidationError,
+  DocumentMapper: () => DocumentMapper,
+  DocumentObject: () => DocumentObject,
+  RedlineEngine: () => RedlineEngine,
+  apply_edits_to_markdown: () => apply_edits_to_markdown,
+  extractTextFromBuffer: () => extractTextFromBuffer,
+  extract_outline: () => extract_outline,
+  generate_edits_from_text: () => generate_edits_from_text,
+  identifyEngine: () => identifyEngine,
+  paginate: () => paginate,
+  split_structural_appendix: () => split_structural_appendix,
+  trim_common_context: () => trim_common_context
+});
+module.exports = __toCommonJS(index_exports);
+
+// src/docx/bridge.ts
+var import_jszip = __toESM(require("jszip"), 1);
+
+// src/docx/dom.ts
+var import_xmldom = require("@xmldom/xmldom");
+function findChild(element, tagName) {
+  for (let i = 0; i < element.childNodes.length; i++) {
+    const child = element.childNodes[i];
+    if (child.nodeType === 1 && child.tagName === tagName) {
+      return child;
+    }
+  }
+  return null;
+}
+function findAllDescendants(element, tagName) {
+  return Array.from(element.getElementsByTagName(tagName));
+}
+function parseXml(xmlString) {
+  return new import_xmldom.DOMParser().parseFromString(xmlString, "text/xml");
+}
+function serializeXml(node) {
+  return new import_xmldom.XMLSerializer().serializeToString(node);
+}
+
+// src/docx/bridge.ts
+var Relationship = class {
+  constructor(id, type, target, isExternal) {
+    this.id = id;
+    this.type = type;
+    this.target = target;
+    this.isExternal = isExternal;
+  }
+  id;
+  type;
+  target;
+  isExternal;
+};
+var Part = class {
+  constructor(partname, blob, element, contentType) {
+    this.partname = partname;
+    this.blob = blob;
+    this.contentType = contentType;
+    this._element = element;
+  }
+  partname;
+  blob;
+  contentType;
+  rels = /* @__PURE__ */ new Map();
+  _element;
+  addRelationship(id, type, target, isExternal = false) {
+    this.rels.set(id, new Relationship(id, type, target, isExternal));
+    if (this._element.tagName === "Relationships") {
+      const doc = this._element.ownerDocument;
+      if (doc) {
+        const relEl = doc.createElement("Relationship");
+        relEl.setAttribute("Id", id);
+        relEl.setAttribute("Type", type);
+        relEl.setAttribute("Target", target);
+        if (isExternal) relEl.setAttribute("TargetMode", "External");
+        this._element.appendChild(relEl);
+      }
+    }
+  }
+};
+var DocxPackage = class {
+  constructor(zip) {
+    this.zip = zip;
+  }
+  zip;
+  parts = [];
+  mainDocumentPart;
+  getPartByPath(path) {
+    const searchPath = path.startsWith("/") ? path.substring(1) : path;
+    return this.parts.find((p) => p.partname === searchPath || p.partname === "/" + searchPath);
+  }
+  nextPartname(pattern) {
+    let i = 1;
+    while (true) {
+      const candidate = pattern.replace("%d", i === 1 ? "" : i.toString());
+      if (!this.getPartByPath(candidate)) return candidate;
+      i++;
+    }
+  }
+  addPart(partname, contentType, xmlString) {
+    const doc = parseXml(xmlString);
+    const part = new Part(partname, xmlString, doc.documentElement, contentType);
+    this.parts.push(part);
+    const ctPart = this.getPartByPath("[Content_Types].xml");
+    if (ctPart) {
+      const docCT = ctPart._element.ownerDocument;
+      if (docCT) {
+        const override = docCT.createElement("Override");
+        override.setAttribute("PartName", partname);
+        override.setAttribute("ContentType", contentType);
+        ctPart._element.appendChild(override);
+      }
+    }
+    return part;
+  }
+  getOrCreateRelsPart(sourcePartname) {
+    const parts = sourcePartname.split("/");
+    const file = parts.pop();
+    const relsPath = parts.join("/") + "/_rels/" + file + ".rels";
+    let relsPart = this.getPartByPath(relsPath);
+    if (!relsPart) {
+      const xml = `<?xml version="1.0" encoding="UTF-8" standalone="yes"?>
+<Relationships xmlns="http://schemas.openxmlformats.org/package/2006/relationships"></Relationships>`;
+      relsPart = this.addPart(relsPath, "application/vnd.openxmlformats-package.relationships+xml", xml);
+    }
+    return relsPart;
+  }
+};
+var DocumentObject = class _DocumentObject {
+  constructor(pkg, part) {
+    this.pkg = pkg;
+    this.part = part;
+  }
+  pkg;
+  part;
+  settings = { oddAndEvenPagesHeaderFooter: false };
+  // Simplification for the TS port: sections hold header/footer refs
+  sections = [];
+  get element() {
+    return findChild(this.part._element, "w:body") || this.part._element;
+  }
+  /**
+   * Main entrypoint for loading a DOCX buffer into the DOM wrapper.
+   */
+  static async load(buffer) {
+    const zip = await import_jszip.default.loadAsync(buffer);
+    const pkg = new DocxPackage(zip);
+    const ctFile = zip.file("[Content_Types].xml");
+    let contentTypes = {};
+    if (ctFile) {
+      const ctXml = parseXml(await ctFile.async("text"));
+      const overrides = findAllDescendants(ctXml.documentElement, "Override");
+      for (const override of overrides) {
+        contentTypes[override.getAttribute("PartName") || ""] = override.getAttribute("ContentType") || "";
+      }
+    }
+    for (const [path, file] of Object.entries(zip.files)) {
+      if (!file.dir && (path.endsWith(".xml") || path.endsWith(".rels"))) {
+        const text = await file.async("text");
+        const doc = parseXml(text);
+        const cType = contentTypes["/" + path] || "application/xml";
+        const part = new Part("/" + path, text, doc.documentElement, cType);
+        pkg.parts.push(part);
+      }
+    }
+    const mainPart = pkg.getPartByPath("word/document.xml");
+    if (!mainPart) throw new Error("Invalid DOCX: Missing word/document.xml");
+    pkg.mainDocumentPart = mainPart;
+    const relsPart = pkg.getPartByPath("word/_rels/document.xml.rels");
+    if (relsPart) {
+      const relElements = findAllDescendants(relsPart._element, "Relationship");
+      for (const rel of relElements) {
+        const rId = rel.getAttribute("Id");
+        const target = rel.getAttribute("Target");
+        const type = rel.getAttribute("Type");
+        const targetMode = rel.getAttribute("TargetMode");
+        if (rId && target && type) {
+          mainPart.rels.set(rId, new Relationship(rId, type, target, targetMode === "External"));
+        }
+      }
+    }
+    return new _DocumentObject(pkg, mainPart);
+  }
+  relateTo(part, relType) {
+    let rId = 1;
+    while (this.part.rels.has(`rId${rId}`)) rId++;
+    const id = `rId${rId}`;
+    const target = part.partname.split("/").pop();
+    this.part.rels.set(id, new Relationship(id, relType, target, false));
+    const relsPart = this.pkg.getOrCreateRelsPart(this.part.partname);
+    relsPart.addRelationship(id, relType, target, false);
+  }
+  async save() {
+    for (const part of this.pkg.parts) {
+      let xmlStr = serializeXml(part._element.ownerDocument || part._element);
+      if (!xmlStr.startsWith("<?xml")) {
+        xmlStr = '<?xml version="1.0" encoding="UTF-8" standalone="yes"?>\n' + xmlStr;
+      }
+      this.pkg.zip.file(part.partname.substring(1), xmlStr);
+    }
+    return this.pkg.zip.generateAsync({ type: "nodebuffer" });
+  }
+};
+
+// src/docx/primitives.ts
+var Paragraph = class {
+  constructor(_element, _parent) {
+    this._element = _element;
+    this._parent = _parent;
+  }
+  _element;
+  _parent;
+  get text() {
+    let t = "";
+    const texts = this._element.getElementsByTagName("w:t");
+    for (let i = 0; i < texts.length; i++) {
+      t += texts[i].textContent || "";
+    }
+    return t;
+  }
+};
+var Run = class {
+  constructor(_element, _parent) {
+    this._element = _element;
+    this._parent = _parent;
+  }
+  _element;
+  _parent;
+};
+var Cell = class {
+  constructor(_element, _parent) {
+    this._element = _element;
+    this._parent = _parent;
+  }
+  _element;
+  _parent;
+};
+var Row = class {
+  constructor(_element, _parent) {
+    this._element = _element;
+    this._parent = _parent;
+    const tcs = this._element.getElementsByTagName("w:tc");
+    for (let i = 0; i < tcs.length; i++) {
+      this.cells.push(new Cell(tcs[i], this));
+    }
+  }
+  _element;
+  _parent;
+  cells = [];
+};
+var Table = class {
+  constructor(_element, _parent) {
+    this._element = _element;
+    this._parent = _parent;
+    const trs = this._element.getElementsByTagName("w:tr");
+    for (let i = 0; i < trs.length; i++) {
+      this.rows.push(new Row(trs[i], this));
+    }
+  }
+  _element;
+  _parent;
+  rows = [];
+};
+var NotesPart = class {
+  constructor(part, note_type) {
+    this.part = part;
+    this.note_type = note_type;
+    this._element = part._element;
+  }
+  part;
+  note_type;
+  _element;
+};
+var FootnoteItem = class {
+  constructor(_element, _parent, note_type) {
+    this._element = _element;
+    this._parent = _parent;
+    this.note_type = note_type;
+    this.id = _element.getAttribute("w:id") || "";
+    this.part = _parent.part;
+  }
+  _element;
+  _parent;
+  note_type;
+  id;
+  part;
+};
+
+// src/utils/docx.ts
+var QN_W_P = "w:p";
+var QN_W_R = "w:r";
+var QN_W_T = "w:t";
+var QN_W_DELTEXT = "w:delText";
+var QN_W_TAB = "w:tab";
+var QN_W_BR = "w:br";
+var QN_W_CR = "w:cr";
+var QN_W_RPR = "w:rPr";
+var QN_W_RPRCHANGE = "w:rPrChange";
+var QN_W_COMMENTREFERENCE = "w:commentReference";
+var QN_W_FOOTNOTEREFERENCE = "w:footnoteReference";
+var QN_W_ENDNOTEREFERENCE = "w:endnoteReference";
+var QN_W_FLDCHAR = "w:fldChar";
+var QN_W_FLDCHARTYPE = "w:fldCharType";
+var QN_W_INSTRTEXT = "w:instrText";
+var QN_W_INS = "w:ins";
+var QN_W_DEL = "w:del";
+var QN_W_ID = "w:id";
+var QN_W_AUTHOR = "w:author";
+var QN_W_DATE = "w:date";
+var QN_W_COMMENTRANGESTART = "w:commentRangeStart";
+var QN_W_COMMENTRANGEEND = "w:commentRangeEnd";
+var QN_W_HYPERLINK = "w:hyperlink";
+var QN_R_ID = "r:id";
+var QN_W_FLDSIMPLE = "w:fldSimple";
+var QN_W_INSTR = "w:instr";
+var QN_W_BOOKMARKSTART = "w:bookmarkStart";
+var QN_W_NAME = "w:name";
+var QN_W_SDT = "w:sdt";
+var QN_W_SMARTTAG = "w:smartTag";
+var QN_W_SDTCONTENT = "w:sdtContent";
+var QN_W_B = "w:b";
+var QN_W_I = "w:i";
+var QN_W_VAL = "w:val";
+var QN_W_PPR = "w:pPr";
+var QN_W_PSTYLE = "w:pStyle";
+var QN_W_OUTLINELVL = "w:outlineLvl";
+var QN_W_NUMPR = "w:numPr";
+var QN_W_NUMID = "w:numId";
+var QN_W_ILVL = "w:ilvl";
+var _CUSTOM_HEADING_NAME_RE = /Heading[ ]?([1-6])(?![0-9])/;
+function _get_style_cache(part) {
+  const pkg = part.package || part.pkg || (part.part ? part.part.pkg : null);
+  if (pkg && pkg._adeu_style_cache) {
+    return pkg._adeu_style_cache;
+  }
+  const cache = {};
+  let default_pstyle = null;
+  const raw_styles = {};
+  const stylesPart = pkg?.getPartByPath("word/styles.xml");
+  if (!stylesPart) {
+    const result2 = [cache, null];
+    if (pkg) pkg._adeu_style_cache = result2;
+    return result2;
+  }
+  const styles = findAllDescendants(stylesPart._element, "w:style");
+  for (const s of styles) {
+    const s_id = s.getAttribute("w:styleId");
+    if (!s_id) continue;
+    const s_type = s.getAttribute("w:type");
+    const is_default = s.getAttribute("w:default") === "1" || s.getAttribute("w:default") === "true";
+    if (s_type === "paragraph" && is_default) default_pstyle = s_id;
+    const name_el = findChild(s, "w:name");
+    const name = name_el ? name_el.getAttribute("w:val") : s_id;
+    const based_on_el = findChild(s, "w:basedOn");
+    const based_on = based_on_el ? based_on_el.getAttribute("w:val") : null;
+    let outline_lvl = null;
+    const pPr = findChild(s, "w:pPr");
+    if (pPr) {
+      const oLvl = findChild(pPr, "w:outlineLvl");
+      if (oLvl) {
+        const val = oLvl.getAttribute("w:val");
+        if (val && /^\d+$/.test(val)) outline_lvl = parseInt(val, 10);
+      }
+    }
+    let bold = null;
+    const rPr = findChild(s, "w:rPr");
+    if (rPr) {
+      const b = findChild(rPr, "w:b");
+      if (b) {
+        const val = b.getAttribute("w:val");
+        bold = val !== "0" && val !== "false" && val !== "off";
+      }
+    }
+    raw_styles[s_id] = { name, based_on, outline_level: outline_lvl, bold };
+  }
+  const resolve_style = (s_id, visited) => {
+    if (cache[s_id]) return cache[s_id];
+    if (visited.has(s_id) || !raw_styles[s_id]) return { name: s_id, outline_level: null, bold: false };
+    visited.add(s_id);
+    const raw = raw_styles[s_id];
+    const based_on_id = raw.based_on;
+    let o_lvl = raw.outline_level;
+    let bold_val = raw.bold !== null ? raw.bold : false;
+    if (based_on_id) {
+      const parent = resolve_style(based_on_id, visited);
+      if (o_lvl === null) o_lvl = parent.outline_level;
+      if (raw.bold === null) bold_val = parent.bold;
+    }
+    const resolved = { name: raw.name, outline_level: o_lvl, bold: bold_val };
+    cache[s_id] = resolved;
+    return resolved;
+  };
+  for (const s_id in raw_styles) resolve_style(s_id, /* @__PURE__ */ new Set());
+  const result = [cache, default_pstyle];
+  if (pkg) pkg._adeu_style_cache = result;
+  return result;
+}
+function _detect_heading_level_from_name(name) {
+  if (!name) return null;
+  const match = name.match(_CUSTOM_HEADING_NAME_RE);
+  return match ? parseInt(match[1], 10) : null;
+}
+function is_native_heading(paragraph, style_cache, default_pstyle) {
+  if (!style_cache) {
+    [style_cache, default_pstyle] = _get_style_cache(paragraph._parent.part || paragraph._parent);
+  }
+  const pPr = findChild(paragraph._element, QN_W_PPR);
+  if (pPr) {
+    const oLvl = findChild(pPr, QN_W_OUTLINELVL);
+    if (oLvl) {
+      const val = oLvl.getAttribute(QN_W_VAL);
+      if (val && /^\d+$/.test(val)) {
+        const lvl = parseInt(val, 10);
+        if (lvl >= 0 && lvl <= 8) return true;
+      }
+    }
+  }
+  let style_id = default_pstyle;
+  if (pPr) {
+    const pStyle = findChild(pPr, QN_W_PSTYLE);
+    if (pStyle) style_id = pStyle.getAttribute(QN_W_VAL) || default_pstyle;
+  }
+  const style_info = style_id && style_cache ? style_cache[style_id] : null;
+  if (style_info && style_info.outline_level !== null && style_info.outline_level >= 0 && style_info.outline_level <= 8) {
+    return true;
+  }
+  const style_name = style_info ? style_info.name : null;
+  if (style_name?.startsWith("Heading")) return true;
+  if (style_name === "Title") return true;
+  if (style_name && style_name !== "Normal") {
+    if (_detect_heading_level_from_name(style_name) !== null) return true;
+  }
+  return false;
+}
+function get_paragraph_prefix(paragraph, style_cache, default_pstyle) {
+  if (!style_cache) {
+    [style_cache, default_pstyle] = _get_style_cache(paragraph._parent.part || paragraph._parent);
+  }
+  const pPr = findChild(paragraph._element, QN_W_PPR);
+  if (pPr) {
+    const oLvl = findChild(pPr, QN_W_OUTLINELVL);
+    if (oLvl) {
+      const val = oLvl.getAttribute(QN_W_VAL);
+      if (val && /^\d+$/.test(val)) {
+        const lvl = parseInt(val, 10);
+        if (lvl >= 0 && lvl <= 8) return "#".repeat(lvl + 1) + " ";
+      }
+    }
+  }
+  let style_id = default_pstyle;
+  if (pPr) {
+    const pStyle = findChild(pPr, QN_W_PSTYLE);
+    if (pStyle) style_id = pStyle.getAttribute(QN_W_VAL) || default_pstyle;
+  }
+  const style_info = style_id && style_cache ? style_cache[style_id] : null;
+  if (style_info && style_info.outline_level !== null && style_info.outline_level >= 0 && style_info.outline_level <= 8) {
+    return "#".repeat(style_info.outline_level + 1) + " ";
+  }
+  const style_name = style_info ? style_info.name : null;
+  if (style_name?.startsWith("Heading")) {
+    const match = style_name.replace("Heading", "").trim();
+    if (/^\d+$/.test(match)) return "#".repeat(parseInt(match, 10)) + " ";
+  }
+  if (style_name === "Title") return "# ";
+  if (pPr) {
+    const numPr = findChild(pPr, QN_W_NUMPR);
+    if (numPr) {
+      const numId = findChild(numPr, QN_W_NUMID);
+      if (numId && numId.getAttribute(QN_W_VAL) !== "0") {
+        let level = 0;
+        const ilvl = findChild(numPr, QN_W_ILVL);
+        if (ilvl) {
+          const valAttr = ilvl.getAttribute(QN_W_VAL);
+          if (valAttr) level = parseInt(valAttr, 10) || 0;
+        }
+        return "    ".repeat(level) + "* ";
+      }
+    }
+  }
+  if (style_name && style_name !== "Normal") {
+    const custom_level = _detect_heading_level_from_name(style_name);
+    if (custom_level !== null) return "#".repeat(custom_level) + " ";
+  }
+  if (!style_name || style_name === "Normal") {
+    const text = paragraph.text.trim();
+    if (text && text.length < 100 && text === text.toUpperCase()) {
+      let is_bold = false;
+      if (style_info?.bold) {
+        is_bold = true;
+      } else {
+        const runs = findAllDescendants(paragraph._element, QN_W_R);
+        for (const r of runs) {
+          const tList = findAllDescendants(r, QN_W_T);
+          const tText = tList.map((t) => t.textContent || "").join("");
+          if (tText.trim()) {
+            const rPr_run = findChild(r, QN_W_RPR);
+            if (rPr_run) {
+              const b = findChild(rPr_run, QN_W_B);
+              if (b && b.getAttribute(QN_W_VAL) !== "0" && b.getAttribute(QN_W_VAL) !== "false") {
+                is_bold = true;
+              }
+            }
+            break;
+          }
+        }
+      }
+      if (is_bold) return "## ";
+    }
+  }
+  return "";
+}
+function is_heading_paragraph(paragraph, style_cache, default_pstyle) {
+  const prefix = get_paragraph_prefix(paragraph, style_cache, default_pstyle);
+  if (!prefix) return false;
+  const stripped = prefix.trimEnd();
+  return stripped.length > 0 && stripped === "#".repeat(stripped.length);
+}
+function get_run_style_markers(run, is_heading = null) {
+  let prefix = "";
+  let suffix = "";
+  const rPr = findChild(run._element, QN_W_RPR);
+  let is_bold = false;
+  let is_italic = false;
+  if (rPr) {
+    const b = findChild(rPr, QN_W_B);
+    if (b && b.getAttribute(QN_W_VAL) !== "0" && b.getAttribute(QN_W_VAL) !== "false") is_bold = true;
+    const i = findChild(rPr, QN_W_I);
+    if (i && i.getAttribute(QN_W_VAL) !== "0" && i.getAttribute(QN_W_VAL) !== "false") is_italic = true;
+  }
+  if (is_heading === null) {
+    const parent = run._parent;
+    is_heading = parent instanceof Paragraph ? is_native_heading(parent) : false;
+  }
+  if (is_bold && !is_heading) {
+    prefix += "**";
+    suffix = "**" + suffix;
+  }
+  if (is_italic) {
+    prefix += "_";
+    suffix = "_" + suffix;
+  }
+  return [prefix, suffix];
+}
+function apply_formatting_to_segments(text, prefix, suffix) {
+  if (!prefix && !suffix) return text;
+  if (!text) return "";
+  if (!text.includes("\n")) return `${prefix}${text}${suffix}`;
+  const parts = text.split("\n");
+  return parts.map((p) => p ? `${prefix}${p}${suffix}` : "").join("\n");
+}
+function get_run_text(run) {
+  let text = "";
+  for (let i = 0; i < run._element.childNodes.length; i++) {
+    const child = run._element.childNodes[i];
+    if (child.nodeType !== 1) continue;
+    if (child.tagName === QN_W_T || child.tagName === QN_W_DELTEXT) {
+      const raw = child.textContent || "";
+      text += raw.replace(/\t/g, " ");
+    } else if (child.tagName === QN_W_TAB) {
+      text += " ";
+    } else if (child.tagName === QN_W_BR || child.tagName === QN_W_CR) {
+      text += "\n";
+    }
+  }
+  return text;
+}
+function* iter_block_items(parent) {
+  const parent_elm = parent._element || parent.element || parent;
+  if (parent.constructor.name === "NotesPart") {
+    const tag = parent.note_type === "fn" ? "w:footnote" : "w:endnote";
+    const notes = findAllDescendants(parent_elm, tag);
+    for (const child of notes) {
+      if (child.getAttribute("w:type") === "separator" || child.getAttribute("w:type") === "continuationSeparator") continue;
+      yield new FootnoteItem(child, parent, parent.note_type);
+    }
+    return;
+  }
+  for (let i = 0; i < parent_elm.childNodes.length; i++) {
+    const child = parent_elm.childNodes[i];
+    if (child.nodeType !== 1) continue;
+    if (child.tagName === QN_W_P) {
+      yield new Paragraph(child, parent);
+    } else if (child.tagName === "w:tbl") {
+      yield new Table(child, parent);
+    }
+  }
+}
+function* iter_document_parts(doc) {
+  yield doc;
+  const fnPart = doc.pkg.getPartByPath("word/footnotes.xml");
+  const enPart = doc.pkg.getPartByPath("word/endnotes.xml");
+  if (fnPart) yield new NotesPart(fnPart, "fn");
+  if (enPart) yield new NotesPart(enPart, "en");
+}
+function _is_page_instr(instr) {
+  if (!instr) return false;
+  const parts = instr.toUpperCase().trim().split(/\s+/);
+  return parts.length > 0 && (parts[0] === "PAGE" || parts[0] === "NUMPAGES");
+}
+function* iter_paragraph_content(paragraph) {
+  let in_complex_field = false;
+  let current_instr = "";
+  let hide_result = false;
+  function* process_run_element(r_element) {
+    let c_id = null;
+    const rPr = findChild(r_element, QN_W_RPR);
+    if (rPr) {
+      const rPrChange = findChild(rPr, QN_W_RPRCHANGE);
+      if (rPrChange) {
+        c_id = rPrChange.getAttribute(QN_W_ID);
+        yield { type: "fmt_start", id: c_id, author: rPrChange.getAttribute(QN_W_AUTHOR) || void 0, date: rPrChange.getAttribute(QN_W_DATE) || void 0 };
+      }
+    }
+    for (let i = 0; i < r_element.childNodes.length; i++) {
+      const child = r_element.childNodes[i];
+      if (child.nodeType !== 1) continue;
+      const tag = child.tagName;
+      if (tag === QN_W_COMMENTREFERENCE) {
+        const ref_id = child.getAttribute(QN_W_ID);
+        if (ref_id) yield { type: "ref", id: ref_id };
+      } else if (tag === QN_W_FOOTNOTEREFERENCE) {
+        const f_id = child.getAttribute(QN_W_ID);
+        if (f_id) yield { type: "footnote", id: f_id };
+      } else if (tag === QN_W_ENDNOTEREFERENCE) {
+        const e_id = child.getAttribute(QN_W_ID);
+        if (e_id) yield { type: "endnote", id: e_id };
+      } else if (tag === QN_W_FLDCHAR) {
+        const fld_type = child.getAttribute(QN_W_FLDCHARTYPE);
+        if (fld_type === "begin") {
+          in_complex_field = true;
+          current_instr = "";
+        } else if (fld_type === "separate") {
+          if (_is_page_instr(current_instr)) hide_result = true;
+          else {
+            const parts = current_instr.trim().split(/\s+/);
+            if (parts.length > 1 && parts[0] === "REF") yield { type: "xref_start", id: parts[1] };
+          }
+        } else if (fld_type === "end") {
+          if (!hide_result) {
+            const parts = current_instr.trim().split(/\s+/);
+            if (parts.length > 1 && parts[0] === "REF") yield { type: "xref_end", id: parts[1] };
+          }
+          in_complex_field = false;
+          current_instr = "";
+          hide_result = false;
+        }
+      } else if (tag === QN_W_INSTRTEXT && in_complex_field && !hide_result) {
+        current_instr += child.textContent || "";
+      }
+    }
+    if (!hide_result) yield new Run(r_element, paragraph);
+    if (c_id !== null) yield { type: "fmt_end", id: c_id };
+  }
+  function* traverse_node(node) {
+    for (let i = 0; i < node.childNodes.length; i++) {
+      const child = node.childNodes[i];
+      if (child.nodeType !== 1) continue;
+      const tag = child.tagName;
+      if (tag === QN_W_R) yield* process_run_element(child);
+      else if (tag === QN_W_INS) {
+        const i_id = child.getAttribute(QN_W_ID);
+        yield { type: "ins_start", id: i_id, author: child.getAttribute(QN_W_AUTHOR) || void 0, date: child.getAttribute(QN_W_DATE) || void 0 };
+        yield* traverse_node(child);
+        yield { type: "ins_end", id: i_id };
+      } else if (tag === QN_W_DEL) {
+        const d_id = child.getAttribute(QN_W_ID);
+        yield { type: "del_start", id: d_id, author: child.getAttribute(QN_W_AUTHOR) || void 0, date: child.getAttribute(QN_W_DATE) || void 0 };
+        yield* traverse_node(child);
+        yield { type: "del_end", id: d_id };
+      } else if (tag === QN_W_COMMENTRANGESTART) yield { type: "start", id: child.getAttribute(QN_W_ID) };
+      else if (tag === QN_W_COMMENTRANGEEND) yield { type: "end", id: child.getAttribute(QN_W_ID) };
+      else if (tag === QN_W_HYPERLINK) {
+        const rId = child.getAttribute(QN_R_ID);
+        let url = "";
+        if (rId && paragraph._parent.part) {
+          const rel = paragraph._parent.part.rels.get(rId);
+          if (rel && rel.isExternal) url = rel.target;
+        }
+        if (url) yield { type: "hyperlink_start", id: rId, date: url };
+        yield* traverse_node(child);
+        if (url) yield { type: "hyperlink_end", id: rId, date: url };
+      } else if (tag === QN_W_FLDSIMPLE) {
+        const instr = child.getAttribute(QN_W_INSTR) || "";
+        const parts = instr.trim().split(/\s+/);
+        const target = parts.length > 1 && parts[0] === "REF" ? parts[1] : "";
+        if (target) yield { type: "xref_start", id: target };
+        yield* traverse_node(child);
+        if (target) yield { type: "xref_end", id: target };
+      } else if (tag === QN_W_BOOKMARKSTART) {
+        const b_name = child.getAttribute(QN_W_NAME);
+        if (b_name && (!b_name.startsWith("_") || b_name.startsWith("_Ref"))) yield { type: "bookmark", id: b_name };
+      } else if (tag === QN_W_SDT || tag === QN_W_SMARTTAG || tag === QN_W_SDTCONTENT) {
+        yield* traverse_node(child);
+      }
+    }
+  }
+  yield* traverse_node(paragraph._element);
+}
+
+// src/domain.ts
+function build_structural_appendix(doc, base_text) {
+  return "";
+}
+
+// src/comments.ts
+var NS = {
+  w: "http://schemas.openxmlformats.org/wordprocessingml/2006/main",
+  w14: "http://schemas.microsoft.com/office/word/2010/wordml",
+  w15: "http://schemas.microsoft.com/office/word/2012/wordml",
+  w16cid: "http://schemas.microsoft.com/office/word/2016/wordml/cid",
+  w16cex: "http://schemas.microsoft.com/office/word/2018/wordml/cex",
+  mc: "http://schemas.openxmlformats.org/markup-compatibility/2006"
+};
+var CT = {
+  COMMENTS: "application/vnd.openxmlformats-officedocument.wordprocessingml.comments+xml",
+  EXTENDED: "application/vnd.openxmlformats-officedocument.wordprocessingml.commentsExtended+xml",
+  IDS: "application/vnd.openxmlformats-officedocument.wordprocessingml.commentsIds+xml",
+  EXTENSIBLE: "application/vnd.openxmlformats-officedocument.wordprocessingml.commentsExtensible+xml"
+};
+var RT = {
+  COMMENTS: "http://schemas.openxmlformats.org/officeDocument/2006/relationships/comments",
+  EXTENDED: "http://schemas.microsoft.com/office/2011/relationships/commentsExtended",
+  IDS: "http://schemas.microsoft.com/office/2016/09/relationships/commentsIds",
+  EXTENSIBLE: "http://schemas.microsoft.com/office/2018/08/relationships/commentsExtensible"
+};
+var CommentsManager = class {
+  constructor(doc) {
+    this.doc = doc;
+  }
+  doc;
+  _commentsPart = null;
+  _extendedPart = null;
+  _idsPart = null;
+  _extensiblePart = null;
+  _nextId = null;
+  get commentsPart() {
+    if (!this._commentsPart) {
+      this._commentsPart = this._getOrCreateCommentsPart();
+      this._ensureNamespaces();
+    }
+    return this._commentsPart;
+  }
+  get extendedPart() {
+    if (!this._extendedPart) this._extendedPart = this._getOrCreateExtendedPart();
+    return this._extendedPart;
+  }
+  get idsPart() {
+    if (!this._idsPart) this._idsPart = this._getOrCreateIdsPart();
+    return this._idsPart;
+  }
+  get extensiblePart() {
+    if (!this._extensiblePart) this._extensiblePart = this._getOrCreateExtensiblePart();
+    return this._extensiblePart;
+  }
+  get nextId() {
+    if (this._nextId === null) this._nextId = this._getNextCommentId();
+    return this._nextId;
+  }
+  set nextId(value) {
+    this._nextId = value;
+  }
+  _getExistingPartByType(contentType) {
+    return this.doc.pkg.parts.find((p) => p.contentType === contentType) || null;
+  }
+  _linkPart(part, relType) {
+    for (const rel of this.doc.part.rels.values()) {
+      if (!rel.isExternal && rel.target === part.partname.split("/").pop()) {
+        return part;
+      }
+    }
+    this.doc.relateTo(part, relType);
+    return part;
+  }
+  _getOrCreateCommentsPart() {
+    let part = this._getExistingPartByType(CT.COMMENTS);
+    if (part) return this._linkPart(part, RT.COMMENTS);
+    const partname = this.doc.pkg.nextPartname("/word/comments%d.xml");
+    const xml = `<w:comments xmlns:w="${NS.w}" xmlns:w14="${NS.w14}" xmlns:w15="${NS.w15}" xmlns:w16cid="${NS.w16cid}" xmlns:w16cex="${NS.w16cex}" xmlns:mc="${NS.mc}" mc:Ignorable="w14 w15 w16cid w16cex"></w:comments>`;
+    part = this.doc.pkg.addPart(partname, CT.COMMENTS, xml);
+    this.doc.relateTo(part, RT.COMMENTS);
+    return part;
+  }
+  _getOrCreateExtendedPart() {
+    let part = this._getExistingPartByType(CT.EXTENDED);
+    if (part) return this._linkPart(part, RT.EXTENDED);
+    const partname = this.doc.pkg.nextPartname("/word/commentsExtended%d.xml");
+    const xml = `<w15:commentsEx xmlns:w15="${NS.w15}"></w15:commentsEx>`;
+    part = this.doc.pkg.addPart(partname, CT.EXTENDED, xml);
+    this.doc.relateTo(part, RT.EXTENDED);
+    return part;
+  }
+  _getOrCreateIdsPart() {
+    let part = this._getExistingPartByType(CT.IDS);
+    if (part) return this._linkPart(part, RT.IDS);
+    const partname = this.doc.pkg.nextPartname("/word/commentsIds%d.xml");
+    const xml = `<w16cid:commentsIds xmlns:w16cid="${NS.w16cid}"></w16cid:commentsIds>`;
+    part = this.doc.pkg.addPart(partname, CT.IDS, xml);
+    this.doc.relateTo(part, RT.IDS);
+    return part;
+  }
+  _getOrCreateExtensiblePart() {
+    let part = this._getExistingPartByType(CT.EXTENSIBLE);
+    if (part) return this._linkPart(part, RT.EXTENSIBLE);
+    const partname = this.doc.pkg.nextPartname("/word/commentsExtensible%d.xml");
+    const xml = `<w16cex:commentsExtensible xmlns:w16cex="${NS.w16cex}"></w16cex:commentsExtensible>`;
+    part = this.doc.pkg.addPart(partname, CT.EXTENSIBLE, xml);
+    this.doc.relateTo(part, RT.EXTENSIBLE);
+    return part;
+  }
+  _ensureNamespaces() {
+  }
+  _getNextCommentId() {
+    const ids = [0];
+    const part = this._getExistingPartByType(CT.COMMENTS);
+    if (part) {
+      const comments = findAllDescendants(part._element, "w:comment");
+      for (const c of comments) {
+        const idStr = c.getAttribute("w:id");
+        if (idStr) ids.push(parseInt(idStr, 10) || 0);
+      }
+    }
+    return Math.max(...ids) + 1;
+  }
+  _generateHexId() {
+    return Math.floor(Math.random() * 4294967295).toString(16).toUpperCase().padStart(8, "0");
+  }
+  _getInitials(author) {
+    if (!author) return "";
+    return author.split(" ").filter(Boolean).map((p) => p[0]).join("").toUpperCase();
+  }
+  _findParaIdForComment(commentId) {
+    if (!this._commentsPart) return null;
+    for (const c of findAllDescendants(this._commentsPart._element, "w:comment")) {
+      if (c.getAttribute("w:id") === commentId) {
+        for (const p of findAllDescendants(c, "w:p")) {
+          const pid = p.getAttribute("w14:paraId");
+          if (pid) return pid;
+        }
+      }
+    }
+    return null;
+  }
+  _findThreadRootParaId(commentId) {
+    const directParaId = this._findParaIdForComment(commentId);
+    const extPart = this._getExistingPartByType(CT.EXTENDED);
+    if (!directParaId || !extPart) return directParaId;
+    for (let i = 0; i < extPart._element.childNodes.length; i++) {
+      const child = extPart._element.childNodes[i];
+      if (child.nodeType !== 1) continue;
+      if (child.getAttribute("w15:paraId") === directParaId) {
+        const parent = child.getAttribute("w15:paraIdParent");
+        if (parent) return parent;
+      }
+    }
+    return directParaId;
+  }
+  addComment(author, text, parentId = null) {
+    const commentId = this.nextId.toString();
+    this.nextId++;
+    const now = (/* @__PURE__ */ new Date()).toISOString().replace(/\.\d{3}Z$/, "Z");
+    const doc = this.commentsPart._element.ownerDocument;
+    const comment = doc.createElement("w:comment");
+    comment.setAttribute("w:id", commentId);
+    comment.setAttribute("w:author", author);
+    comment.setAttribute("w:date", now);
+    const initials = this._getInitials(author);
+    if (initials) comment.setAttribute("w:initials", initials);
+    const extPart = this._getExistingPartByType(CT.EXTENDED);
+    if (parentId && !extPart) {
+      comment.setAttribute("w15:p", parentId);
+    }
+    const paraId = this._generateHexId();
+    const rsid = this._generateHexId();
+    const p = doc.createElement("w:p");
+    p.setAttribute("w14:paraId", paraId);
+    p.setAttribute("w14:textId", "77777777");
+    p.setAttribute("w:rsidR", rsid);
+    p.setAttribute("w:rsidRDefault", rsid);
+    p.setAttribute("w:rsidP", rsid);
+    const pPr = doc.createElement("w:pPr");
+    const pStyle = doc.createElement("w:pStyle");
+    pStyle.setAttribute("w:val", "CommentText");
+    pPr.appendChild(pStyle);
+    p.appendChild(pPr);
+    const rRef = doc.createElement("w:r");
+    const rPrRef = doc.createElement("w:rPr");
+    const rStyleRef = doc.createElement("w:rStyle");
+    rStyleRef.setAttribute("w:val", "CommentReference");
+    rPrRef.appendChild(rStyleRef);
+    rRef.appendChild(rPrRef);
+    rRef.appendChild(doc.createElement("w:annotationRef"));
+    p.appendChild(rRef);
+    const r = doc.createElement("w:r");
+    const t = doc.createElement("w:t");
+    t.textContent = text;
+    r.appendChild(t);
+    p.appendChild(r);
+    comment.appendChild(p);
+    this.commentsPart._element.appendChild(comment);
+    if (this.extendedPart) {
+      const parentParaId = parentId ? this._findThreadRootParaId(parentId) : null;
+      const exDoc = this.extendedPart._element.ownerDocument;
+      const commentEx = exDoc.createElement("w15:commentEx");
+      commentEx.setAttribute("w15:paraId", paraId);
+      if (parentParaId) commentEx.setAttribute("w15:paraIdParent", parentParaId);
+      commentEx.setAttribute("w15:done", "0");
+      this.extendedPart._element.appendChild(commentEx);
+    }
+    if (this.idsPart) {
+      const idsDoc = this.idsPart._element.ownerDocument;
+      const commentIdEl = idsDoc.createElement("w16cid:commentId");
+      commentIdEl.setAttribute("w16cid:paraId", paraId);
+      commentIdEl.setAttribute("w16cid:durableId", this._generateHexId());
+      this.idsPart._element.appendChild(commentIdEl);
+    }
+    if (this.extensiblePart) {
+      let durableId = null;
+      for (let i = 0; i < this.idsPart._element.childNodes.length; i++) {
+        const child = this.idsPart._element.childNodes[i];
+        if (child.nodeType === 1 && child.getAttribute("w16cid:paraId") === paraId) {
+          durableId = child.getAttribute("w16cid:durableId");
+          break;
+        }
+      }
+      if (durableId) {
+        const cexDoc = this.extensiblePart._element.ownerDocument;
+        const extEl = cexDoc.createElement("w16cex:commentExtensible");
+        extEl.setAttribute("w16cex:durableId", durableId);
+        extEl.setAttribute("w16cex:dateUtc", now);
+        this.extensiblePart._element.appendChild(extEl);
+      }
+    }
+    return commentId;
+  }
+  deleteComment(commentId) {
+    if (!this._commentsPart) return;
+    let commentEl = null;
+    for (const c of findAllDescendants(this._commentsPart._element, "w:comment")) {
+      if (c.getAttribute("w:id") === commentId) {
+        commentEl = c;
+        break;
+      }
+    }
+    if (!commentEl) return;
+    let paraId = null;
+    for (const p of findAllDescendants(commentEl, "w:p")) {
+      const pid = p.getAttribute("w14:paraId");
+      if (pid) {
+        paraId = pid;
+        break;
+      }
+    }
+    if (paraId) {
+      const repliesToDelete = [];
+      if (this.extendedPart) {
+        for (let i = 0; i < this.extendedPart._element.childNodes.length; i++) {
+          const child = this.extendedPart._element.childNodes[i];
+          if (child.nodeType !== 1) continue;
+          if (child.getAttribute("w15:paraIdParent") === paraId) {
+            const childParaId = child.getAttribute("w15:paraId");
+            if (childParaId) {
+              for (const c of findAllDescendants(this._commentsPart._element, "w:comment")) {
+                for (const p of findAllDescendants(c, "w:p")) {
+                  if (p.getAttribute("w14:paraId") === childParaId) {
+                    const cid = c.getAttribute("w:id");
+                    if (cid) repliesToDelete.push(cid);
+                    break;
+                  }
+                }
+              }
+            }
+          }
+        }
+      }
+      for (const repId of repliesToDelete) {
+        this.deleteComment(repId);
+      }
+      let durableId = null;
+      if (this.idsPart) {
+        const toRemove = [];
+        for (let i = 0; i < this.idsPart._element.childNodes.length; i++) {
+          const child = this.idsPart._element.childNodes[i];
+          if (child.nodeType === 1 && child.getAttribute("w16cid:paraId") === paraId) {
+            durableId = child.getAttribute("w16cid:durableId");
+            toRemove.push(child);
+          }
+        }
+        toRemove.forEach((c) => this.idsPart._element.removeChild(c));
+      }
+      if (this.extendedPart) {
+        const toRemove = [];
+        for (let i = 0; i < this.extendedPart._element.childNodes.length; i++) {
+          const child = this.extendedPart._element.childNodes[i];
+          if (child.nodeType === 1 && child.getAttribute("w15:paraId") === paraId) {
+            toRemove.push(child);
+          }
+        }
+        toRemove.forEach((c) => this.extendedPart._element.removeChild(c));
+      }
+      if (durableId && this.extensiblePart) {
+        const toRemove = [];
+        for (let i = 0; i < this.extensiblePart._element.childNodes.length; i++) {
+          const child = this.extensiblePart._element.childNodes[i];
+          if (child.nodeType === 1 && child.getAttribute("w16cex:durableId") === durableId) {
+            toRemove.push(child);
+          }
+        }
+        toRemove.forEach((c) => this.extensiblePart._element.removeChild(c));
+      }
+    }
+    if (commentEl.parentNode) {
+      commentEl.parentNode.removeChild(commentEl);
+    }
+  }
+};
+function extract_comments_data(pkg) {
+  const docObj = {
+    pkg,
+    part: pkg.mainDocumentPart,
+    relateTo: () => {
+    }
+    // Mock since extraction is read-only
+  };
+  const mgr = new CommentsManager(docObj);
+  const data = {};
+  const part = pkg.parts.find((p) => p.contentType === CT.COMMENTS);
+  if (!part) return data;
+  const para_id_to_cid = {};
+  const comments = findAllDescendants(part._element, "w:comment");
+  for (const c of comments) {
+    const c_id = c.getAttribute("w:id");
+    if (!c_id) continue;
+    const c_author = c.getAttribute("w:author") || "Unknown";
+    const c_date = c.getAttribute("w:date") || "";
+    let is_resolved = false;
+    const val = c.getAttribute("w15:done");
+    if (val === "1" || val === "true" || val === "on") is_resolved = true;
+    let parent_id = c.getAttribute("w15:p") || null;
+    const p_elems = findAllDescendants(c, "w:p");
+    for (const p of p_elems) {
+      const pid = p.getAttribute("w14:paraId");
+      if (pid) para_id_to_cid[pid] = c_id;
+    }
+    const text_parts = [];
+    for (const p of p_elems) {
+      const t_elems = findAllDescendants(p, "w:t");
+      for (const t of t_elems) {
+        if (t.textContent) text_parts.push(t.textContent);
+      }
+      text_parts.push("\n");
+    }
+    const full_text = text_parts.join("").trim();
+    data[c_id] = {
+      author: c_author,
+      text: full_text,
+      date: c_date,
+      resolved: is_resolved,
+      parent_id
+    };
+  }
+  const extPart = pkg.parts.find((p) => p.contentType === CT.EXTENDED);
+  if (extPart) {
+    const children = extPart._element.childNodes;
+    for (let i = 0; i < children.length; i++) {
+      const child = children[i];
+      if (child.nodeType !== 1) continue;
+      const para_id = child.getAttribute("w15:paraId");
+      const parent_para_id = child.getAttribute("w15:paraIdParent");
+      const done_val = child.getAttribute("w15:done");
+      if (para_id) {
+        const c_id = para_id_to_cid[para_id];
+        if (c_id && data[c_id]) {
+          if (parent_para_id) {
+            const p_id = para_id_to_cid[parent_para_id];
+            if (p_id) data[c_id].parent_id = p_id;
+          }
+          if (done_val === "1" || done_val === "true" || done_val === "on") {
+            data[c_id].resolved = true;
+          }
+        }
+      }
+    }
+  }
+  return data;
+}
+
+// src/ingest.ts
+async function extractTextFromBuffer(buffer, cleanView = false) {
+  const doc = await DocumentObject.load(buffer);
+  return _extractTextFromDoc(doc, cleanView);
+}
+function _extractTextFromDoc(doc, cleanView = false, includeAppendix = true) {
+  const comments_map = extract_comments_data(doc.pkg);
+  const full_text = [];
+  let cursor = 0;
+  for (const part of iter_document_parts(doc)) {
+    const part_cursor = full_text.length > 0 ? cursor + 2 : cursor;
+    const part_text = _extract_blocks(part, comments_map, cleanView, part_cursor);
+    if (part_text) {
+      if (full_text.length > 0) cursor += 2;
+      full_text.push(part_text);
+      cursor += part_text.length;
+    }
+  }
+  let base_text = full_text.join("\n\n");
+  if (includeAppendix) {
+    const appendix = build_structural_appendix(doc, base_text);
+    if (appendix) base_text += appendix;
+  }
+  return base_text;
+}
+function _extract_blocks(container, comments_map, cleanView, cursor) {
+  const part = container.part || container;
+  const [style_cache, default_pstyle] = _get_style_cache(part);
+  const blocks = [];
+  let local_cursor = cursor;
+  let is_first_block = true;
+  let is_first_para = true;
+  for (const item of iter_block_items(container)) {
+    if (!is_first_block) local_cursor += 2;
+    const block_start = local_cursor;
+    if (item.constructor.name === "FootnoteItem") {
+      const fn_text = _extract_blocks(item, comments_map, cleanView, block_start);
+      if (fn_text) {
+        blocks.push(fn_text);
+        local_cursor = block_start + fn_text.length;
+        is_first_block = false;
+      } else if (!is_first_block) {
+        local_cursor -= 2;
+      }
+    } else if (item instanceof Paragraph) {
+      let prefix = get_paragraph_prefix(item, style_cache, default_pstyle);
+      if (is_first_para && container.constructor.name === "FootnoteItem") {
+        prefix = `[^${container.note_type}-${container.id}]: ` + prefix;
+      }
+      const p_text = build_paragraph_text(item, comments_map, cleanView, style_cache, default_pstyle);
+      const full_block = prefix + p_text;
+      blocks.push(full_block);
+      local_cursor = block_start + full_block.length;
+      is_first_para = false;
+      is_first_block = false;
+    } else if (item instanceof Table) {
+      const table_text = extract_table(item, comments_map, cleanView, block_start);
+      if (table_text) {
+        blocks.push(table_text);
+        local_cursor = block_start + table_text.length;
+        is_first_block = false;
+      } else if (!is_first_block) {
+        local_cursor -= 2;
+      }
+      is_first_para = false;
+    }
+  }
+  return blocks.join("\n\n");
+}
+function extract_table(table, comments_map, cleanView, cursor) {
+  const rows_text = [];
+  let rows_processed = 0;
+  let local_cursor = cursor;
+  for (const row of table.rows) {
+    const cell_texts = [];
+    const seen_cells = /* @__PURE__ */ new Set();
+    const trPr = findChild(row._element, "w:trPr");
+    const ins = trPr ? findChild(trPr, "w:ins") : null;
+    const del_node = trPr ? findChild(trPr, "w:del") : null;
+    if (cleanView && del_node) continue;
+    const row_start = local_cursor + (rows_processed > 0 ? 1 : 0);
+    const wrapper_prefix_len = !cleanView && ins ? 4 : !cleanView && del_node ? 4 : 0;
+    let cell_cursor = row_start + wrapper_prefix_len;
+    let first_cell = true;
+    for (const cell of row.cells) {
+      if (seen_cells.has(cell)) continue;
+      seen_cells.add(cell);
+      if (!first_cell) cell_cursor += 3;
+      const cell_content = _extract_blocks(cell, comments_map, cleanView, cell_cursor);
+      cell_texts.push(cell_content);
+      cell_cursor += cell_content.length;
+      first_cell = false;
+    }
+    let row_str = cell_texts.join(" | ");
+    if (!cleanView) {
+      if (ins) row_str = `{++ ${row_str} |Chg:${ins.getAttribute("w:id")}++}`;
+      else if (del_node) row_str = `{-- ${row_str} |Chg:${del_node.getAttribute("w:id")}--}`;
+    }
+    rows_text.push(row_str);
+    local_cursor = row_start + row_str.length;
+    rows_processed++;
+  }
+  return rows_text.join("\n");
+}
+function build_paragraph_text(paragraph, comments_map, cleanView, style_cache, default_pstyle) {
+  const parts = [];
+  const active_ins = {};
+  const active_del = {};
+  const active_comments = /* @__PURE__ */ new Set();
+  const active_fmt = {};
+  const deferred_meta_states = [];
+  let pending_text = "";
+  let current_wrappers = ["", ""];
+  let current_style = ["", ""];
+  const items = Array.from(iter_paragraph_content(paragraph));
+  const is_heading = is_heading_paragraph(paragraph, style_cache, default_pstyle);
+  const native_heading = is_native_heading(paragraph, style_cache, default_pstyle);
+  let leading_strip_active = is_heading;
+  for (let i = 0; i < items.length; i++) {
+    const item = items[i];
+    if (item instanceof Run) {
+      const [prefix, suffix] = get_run_style_markers(item, native_heading);
+      const text = get_run_text(item);
+      if (cleanView && Object.keys(active_del).length > 0) continue;
+      if (leading_strip_active) {
+        if (!text || !text.trim()) continue;
+        leading_strip_active = false;
+      }
+      const seg = apply_formatting_to_segments(text, prefix, suffix);
+      if (seg) {
+        const new_wrappers = cleanView ? ["", ""] : _get_wrappers(active_ins, active_del, active_comments, active_fmt);
+        const new_style = [prefix, suffix];
+        if (pending_text && new_wrappers[0] === current_wrappers[0] && new_wrappers[1] === current_wrappers[1]) {
+          if (new_style[0] === current_style[0] && new_style[1] === current_style[1] && current_style[0] !== "" && pending_text.endsWith(current_style[1]) && seg.startsWith(new_style[0])) {
+            pending_text = pending_text.slice(0, -current_style[1].length) + seg.slice(new_style[0].length);
+          } else {
+            pending_text += seg;
+          }
+          current_style = new_style;
+        } else {
+          if (pending_text) parts.push(`${current_wrappers[0]}${pending_text}${current_wrappers[1]}`);
+          pending_text = seg;
+          current_wrappers = new_wrappers;
+          current_style = new_style;
+        }
+        if (!cleanView) {
+          const has_meta = Object.keys(active_ins).length > 0 || Object.keys(active_del).length > 0 || active_comments.size > 0 || Object.keys(active_fmt).length > 0;
+          if (has_meta) {
+            deferred_meta_states.push([{ ...active_ins }, { ...active_del }, new Set(active_comments), { ...active_fmt }]);
+          }
+          let should_defer = false;
+          const is_redline = Object.keys(active_ins).length > 0 || Object.keys(active_del).length > 0 || Object.keys(active_fmt).length > 0;
+          if (is_redline) {
+            let j = i + 1;
+            let next_is_redline = false;
+            let temp_ins = Object.keys(active_ins).length;
+            let temp_del = Object.keys(active_del).length;
+            let temp_fmt = Object.keys(active_fmt).length;
+            while (j < items.length) {
+              const next_item = items[j];
+              if (next_item instanceof Run) {
+                if (!get_run_text(next_item)) {
+                  j++;
+                  continue;
+                }
+                if (temp_ins > 0 || temp_del > 0 || temp_fmt > 0) next_is_redline = true;
+                break;
+              } else {
+                const ev = next_item;
+                if (ev.type === "ins_start") temp_ins++;
+                else if (ev.type === "ins_end") temp_ins = Math.max(0, temp_ins - 1);
+                else if (ev.type === "del_start") temp_del++;
+                else if (ev.type === "del_end") temp_del = Math.max(0, temp_del - 1);
+                else if (ev.type === "fmt_start") temp_fmt++;
+                else if (ev.type === "fmt_end") temp_fmt = Math.max(0, temp_fmt - 1);
+              }
+              j++;
+            }
+            if (next_is_redline) should_defer = true;
+          }
+          if (!should_defer && deferred_meta_states.length > 0) {
+            const meta_block = _build_merged_meta_block(deferred_meta_states, comments_map);
+            if (meta_block) {
+              if (pending_text) {
+                parts.push(`${current_wrappers[0]}${pending_text}${current_wrappers[1]}`);
+                pending_text = "";
+                current_wrappers = ["", ""];
+                current_style = ["", ""];
+              }
+              parts.push(`{>>${meta_block}<<}`);
+            }
+            deferred_meta_states.length = 0;
+          }
+        }
+      }
+    } else {
+      const ev = item;
+      leading_strip_active = false;
+      if (!["ins_start", "ins_end", "del_start", "del_end", "fmt_start", "fmt_end"].includes(ev.type)) {
+        if (pending_text) {
+          parts.push(`${current_wrappers[0]}${pending_text}${current_wrappers[1]}`);
+          pending_text = "";
+          current_wrappers = ["", ""];
+          current_style = ["", ""];
+        }
+      }
+      if (ev.type === "start") active_comments.add(ev.id);
+      else if (ev.type === "end") active_comments.delete(ev.id);
+      else if (ev.type === "ins_start") active_ins[ev.id] = ev;
+      else if (ev.type === "ins_end") delete active_ins[ev.id];
+      else if (ev.type === "del_start") active_del[ev.id] = ev;
+      else if (ev.type === "del_end") delete active_del[ev.id];
+      else if (ev.type === "fmt_start") active_fmt[ev.id] = ev;
+      else if (ev.type === "fmt_end") delete active_fmt[ev.id];
+      else if (ev.type === "footnote" || ev.type === "endnote") {
+        if (pending_text) {
+          parts.push(`${current_wrappers[0]}${pending_text}${current_wrappers[1]}`);
+          pending_text = "";
+          current_wrappers = ["", ""];
+          current_style = ["", ""];
+        }
+        parts.push(`[^${ev.type === "footnote" ? "fn" : "en"}-${ev.id}]`);
+      } else if (ev.type === "hyperlink_start") {
+        if (pending_text) {
+          parts.push(`${current_wrappers[0]}${pending_text}${current_wrappers[1]}`);
+          pending_text = "";
+          current_wrappers = ["", ""];
+          current_style = ["", ""];
+        }
+        parts.push("[");
+      } else if (ev.type === "hyperlink_end") {
+        if (pending_text) {
+          parts.push(`${current_wrappers[0]}${pending_text}${current_wrappers[1]}`);
+          pending_text = "";
+          current_wrappers = ["", ""];
+          current_style = ["", ""];
+        }
+        parts.push(`](${ev.date})`);
+      } else if (ev.type === "xref_start") {
+        if (pending_text) {
+          parts.push(`${current_wrappers[0]}${pending_text}${current_wrappers[1]}`);
+          pending_text = "";
+          current_wrappers = ["", ""];
+          current_style = ["", ""];
+        }
+        parts.push("[~");
+      } else if (ev.type === "xref_end") {
+        if (pending_text) {
+          parts.push(`${current_wrappers[0]}${pending_text}${current_wrappers[1]}`);
+          pending_text = "";
+          current_wrappers = ["", ""];
+          current_style = ["", ""];
+        }
+        parts.push(`~](#${ev.id})`);
+      } else if (ev.type === "bookmark") {
+        if (pending_text) {
+          parts.push(`${current_wrappers[0]}${pending_text}${current_wrappers[1]}`);
+          pending_text = "";
+          current_wrappers = ["", ""];
+          current_style = ["", ""];
+        }
+        parts.push(`{#${ev.id}}`);
+      }
+    }
+  }
+  if (pending_text) parts.push(`${current_wrappers[0]}${pending_text}${current_wrappers[1]}`);
+  if (deferred_meta_states.length > 0) {
+    const meta_block = _build_merged_meta_block(deferred_meta_states, comments_map);
+    if (meta_block) parts.push(`{>>${meta_block}<<}`);
+  }
+  return parts.join("");
+}
+function _get_wrappers(ins, del, comments, fmt) {
+  if (Object.keys(del).length > 0) return ["{--", "--}"];
+  if (Object.keys(ins).length > 0) return ["{++", "++}"];
+  if (comments.size > 0 || Object.keys(fmt).length > 0) return ["{==", "==}"];
+  return ["", ""];
+}
+function _build_merged_meta_block(states_list, comments_map) {
+  const change_lines = [];
+  const comment_lines = [];
+  const seen_sigs = /* @__PURE__ */ new Set();
+  for (const [ins_map, del_map, comments_set, fmt_map] of states_list) {
+    let render_comment2 = function(cid) {
+      if (!comments_map[cid]) return;
+      const sig = `Com:${cid}`;
+      if (seen_sigs.has(sig)) return;
+      const data = comments_map[cid];
+      let header = `[${sig}] ${data.author}`;
+      if (data.date) header += ` @ ${data.date}`;
+      if (data.resolved) header += `(RESOLVED)`;
+      comment_lines.push(`${header}: ${data.text}`);
+      seen_sigs.add(sig);
+      if (children_map[cid]) {
+        const children = children_map[cid].sort((a, b) => (comments_map[a]?.date || "").localeCompare(comments_map[b]?.date || ""));
+        for (const child_id of children) {
+          render_comment2(child_id);
+        }
+      }
+    };
+    var render_comment = render_comment2;
+    for (const [uid, meta] of Object.entries(ins_map)) {
+      const sig = `Chg:${uid}`;
+      if (!seen_sigs.has(sig)) {
+        change_lines.push(`[${sig} insert] ${meta.author || "Unknown"}`);
+        seen_sigs.add(sig);
+      }
+    }
+    for (const [uid, meta] of Object.entries(del_map)) {
+      const sig = `Chg:${uid}`;
+      if (!seen_sigs.has(sig)) {
+        change_lines.push(`[${sig} delete] ${meta.author || "Unknown"}`);
+        seen_sigs.add(sig);
+      }
+    }
+    for (const [uid, meta] of Object.entries(fmt_map)) {
+      const sig = `Chg:${uid}`;
+      if (!seen_sigs.has(sig)) {
+        change_lines.push(`[${sig} format] ${meta.author || "Unknown"}`);
+        seen_sigs.add(sig);
+      }
+    }
+    const children_map = {};
+    for (const [c_id, data] of Object.entries(comments_map)) {
+      const p_id = data.parent_id;
+      if (p_id) {
+        if (!children_map[p_id]) children_map[p_id] = [];
+        children_map[p_id].push(c_id);
+      }
+    }
+    const sorted_ids = Array.from(comments_set).sort();
+    for (const c_id of sorted_ids) {
+      render_comment2(c_id);
+    }
+  }
+  return [...change_lines, ...comment_lines].join("\n");
+}
+
+// src/mapper.ts
+var DocumentMapper = class {
+  doc;
+  clean_view;
+  comments_map;
+  full_text = "";
+  spans = [];
+  appendix_start_index = -1;
+  _text_chunks = [];
+  constructor(doc, clean_view = false) {
+    this.doc = doc;
+    this.clean_view = clean_view;
+    this.comments_map = extract_comments_data(doc.pkg);
+    this._build_map();
+  }
+  _build_map() {
+    let current_offset = 0;
+    this.spans = [];
+    this._text_chunks = [];
+    this.full_text = "";
+    for (const part of iter_document_parts(this.doc)) {
+      current_offset = this._map_blocks(part, current_offset);
+      if (this.spans.length > 0 && this.spans[this.spans.length - 1].text !== "\n\n") {
+        this._add_virtual_text("\n\n", current_offset, null);
+        current_offset += 2;
+      }
+    }
+    while (this.spans.length > 0 && this.spans[this.spans.length - 1].text === "\n\n") {
+      this.spans.pop();
+      this._text_chunks.pop();
+    }
+    this.full_text = this._text_chunks.join("");
+    this.appendix_start_index = -1;
+  }
+  _map_blocks(container, offset) {
+    let current = offset;
+    const c_type = container.constructor.name;
+    const part = container.part || container;
+    const [style_cache, default_pstyle] = _get_style_cache(part);
+    if (c_type === "NotesPart") {
+      const header = container.note_type === "fn" ? "## Footnotes" : "## Endnotes";
+      const sep = `---
+${header}`;
+      this._add_virtual_text(sep, current, null);
+      current += sep.length;
+      this._add_virtual_text("\n\n", current, null);
+      current += 2;
+    }
+    let is_first_para = true;
+    let previous_item = null;
+    for (const item of iter_block_items(container)) {
+      const i_type = item.constructor.name;
+      if (i_type === "FootnoteItem") {
+        current = this._map_blocks(item, current);
+      } else if (item instanceof Paragraph) {
+        if (!is_first_para) {
+          const prev_para = previous_item instanceof Paragraph ? previous_item : null;
+          this._add_virtual_text("\n\n", current, prev_para);
+          current += 2;
+        }
+        let prefix = get_paragraph_prefix(item, style_cache, default_pstyle);
+        if (is_first_para && c_type === "FootnoteItem") {
+          prefix = `[^${container.note_type}-${container.id}]: ` + prefix;
+        }
+        if (prefix) {
+          this._add_virtual_text(prefix, current, item);
+          current += prefix.length;
+        }
+        current = this._map_paragraph_content(item, current, style_cache, default_pstyle);
+        is_first_para = false;
+        previous_item = item;
+      } else if (item instanceof Table) {
+        if (!is_first_para) {
+          const prev_para = previous_item instanceof Paragraph ? previous_item : null;
+          this._add_virtual_text("\n\n", current, prev_para);
+          current += 2;
+        }
+        current = this._map_table(item, current);
+        is_first_para = false;
+        previous_item = item;
+      }
+    }
+    return current;
+  }
+  _map_table(table, offset) {
+    let current = offset;
+    let rows_processed = 0;
+    for (const row of table.rows) {
+      const tr = row._element;
+      const trPr = findChild(tr, "w:trPr");
+      const ins = trPr ? findChild(trPr, "w:ins") : null;
+      const del_node = trPr ? findChild(trPr, "w:del") : null;
+      if (this.clean_view && del_node) continue;
+      if (rows_processed > 0) {
+        this._add_virtual_text("\n", current, null);
+        current += 1;
+      }
+      if (ins && !this.clean_view) {
+        this._add_virtual_text("{++ ", current, null);
+        current += 4;
+      } else if (del_node && !this.clean_view) {
+        this._add_virtual_text("{-- ", current, null);
+        current += 4;
+      }
+      const seen_cells = /* @__PURE__ */ new Set();
+      let cells_processed = 0;
+      for (const cell of row.cells) {
+        if (seen_cells.has(cell)) continue;
+        seen_cells.add(cell);
+        if (cells_processed > 0) {
+          this._add_virtual_text(" | ", current, null);
+          current += 3;
+        }
+        current = this._map_blocks(cell, current);
+        cells_processed += 1;
+      }
+      if (ins && !this.clean_view) {
+        const suffix = ` |Chg:${ins.getAttribute("w:id")}++}`;
+        this._add_virtual_text(suffix, current, null);
+        current += suffix.length;
+      } else if (del_node && !this.clean_view) {
+        const suffix = ` |Chg:${del_node.getAttribute("w:id")}--}`;
+        this._add_virtual_text(suffix, current, null);
+        current += suffix.length;
+      }
+      rows_processed += 1;
+    }
+    return current;
+  }
+  _strip_markdown_formatting(text) {
+    let result = text;
+    result = result.replace(/^#+\s*/gm, "");
+    result = result.replace(/\*\*(\w[\w\s]*\w|\w{2,})\*\*/g, "$1");
+    result = result.replace(/__(\w[\w\s]*\w|\w{2,})__/g, "$1");
+    result = result.replace(/(?<!\w)_(\w[\w\s]*\w|\w{2,})_(?!\w)/g, "$1");
+    result = result.replace(/(?<!\w)\*(\w[\w\s]*\w|\w{2,})\*(?!\w)/g, "$1");
+    return result;
+  }
+  _map_paragraph_content(paragraph, start_offset, style_cache, default_pstyle) {
+    let current = start_offset;
+    const span = { start: current, end: current, text: "", run: null, paragraph };
+    this.spans.push(span);
+    const active_ids = /* @__PURE__ */ new Set();
+    const active_ins = {};
+    const active_del = {};
+    const active_fmt = {};
+    let deferred_meta_states = [];
+    let current_wrappers = ["", ""];
+    let current_style = ["", ""];
+    let active_hyperlink_id = null;
+    let pending_runs = [];
+    const flush_pending_runs = () => {
+      if (pending_runs.length === 0) return;
+      const [s_tok, e_tok] = current_wrappers;
+      if (s_tok) {
+        this._add_virtual_text(s_tok, current, paragraph);
+        current += s_tok.length;
+      }
+      for (const [kind, txt, r_obj, i_id, d_id] of pending_runs) {
+        if (kind === "virtual") {
+          this._add_virtual_text(txt, current, paragraph, active_hyperlink_id);
+        } else {
+          const s = {
+            start: current,
+            end: current + txt.length,
+            text: txt,
+            run: r_obj,
+            paragraph,
+            ins_id: i_id || void 0,
+            del_id: d_id || void 0,
+            hyperlink_id: active_hyperlink_id || void 0
+          };
+          this.spans.push(s);
+          this._text_chunks.push(txt);
+        }
+        current += txt.length;
+      }
+      if (e_tok) {
+        this._add_virtual_text(e_tok, current, paragraph);
+        current += e_tok.length;
+      }
+      pending_runs = [];
+    };
+    const items = Array.from(iter_paragraph_content(paragraph));
+    const is_heading = is_heading_paragraph(paragraph, style_cache, default_pstyle);
+    const native_heading = is_native_heading(paragraph, style_cache, default_pstyle);
+    let leading_strip_active = is_heading;
+    for (let i = 0; i < items.length; i++) {
+      const item = items[i];
+      if (item instanceof Run) {
+        const [prefix, suffix] = get_run_style_markers(item, native_heading);
+        const run_parts = [];
+        const text = get_run_text(item);
+        if (leading_strip_active) {
+          if (text === "" || /^\s*$/.test(text)) continue;
+          leading_strip_active = false;
+        }
+        if (text.includes("\n") && (prefix || suffix)) {
+          const parts = text.split("\n");
+          for (let idx = 0; idx < parts.length; idx++) {
+            if (idx > 0) run_parts.push(["real", "\n", item]);
+            if (parts[idx]) {
+              if (prefix) run_parts.push(["virtual", prefix, null]);
+              run_parts.push(["real", parts[idx], item]);
+              if (suffix) run_parts.push(["virtual", suffix, null]);
+            }
+          }
+        } else {
+          if (prefix) run_parts.push(["virtual", prefix, null]);
+          if (text) run_parts.push(["real", text, item]);
+          if (suffix) run_parts.push(["virtual", suffix, null]);
+        }
+        if (this.clean_view && Object.keys(active_del).length > 0) {
+        }
+        const full_seg_text = run_parts.map((x) => x[1]).join("");
+        const curr_ins_id = Object.keys(active_ins).pop() || null;
+        const curr_del_id = Object.keys(active_del).pop() || null;
+        if (full_seg_text && !(this.clean_view && curr_del_id)) {
+          const new_wrappers = this.clean_view ? ["", ""] : this._get_wrappers(curr_ins_id, curr_del_id, active_ids, active_fmt);
+          const new_style = [prefix, suffix];
+          if (pending_runs.length > 0 && new_wrappers[0] === current_wrappers[0] && new_wrappers[1] === current_wrappers[1]) {
+            let skip_leading_prefix = false;
+            if (new_style[0] === current_style[0] && new_style[1] === current_style[1] && current_style[0] !== "" && pending_runs[pending_runs.length - 1][0] === "virtual" && pending_runs[pending_runs.length - 1][1] === current_style[1]) {
+              pending_runs.pop();
+              skip_leading_prefix = true;
+            }
+            for (const [kind, txt, r_obj] of run_parts) {
+              if (skip_leading_prefix && kind === "virtual" && txt === new_style[0]) {
+                skip_leading_prefix = false;
+                continue;
+              }
+              pending_runs.push([kind, txt, r_obj, curr_ins_id, curr_del_id]);
+            }
+            current_style = new_style;
+          } else {
+            flush_pending_runs();
+            current_wrappers = new_wrappers;
+            current_style = new_style;
+            for (const [kind, txt, r_obj] of run_parts) {
+              pending_runs.push([kind, txt, r_obj, curr_ins_id, curr_del_id]);
+            }
+          }
+        }
+        if (!this.clean_view) {
+          const has_meta = Object.keys(active_ins).length > 0 || Object.keys(active_del).length > 0 || active_ids.size > 0 || Object.keys(active_fmt).length > 0;
+          if (has_meta) {
+            deferred_meta_states.push([{ ...active_ins }, { ...active_del }, new Set(active_ids), { ...active_fmt }]);
+          }
+          let should_defer = false;
+          const is_redline = curr_ins_id !== null || curr_del_id !== null || Object.keys(active_fmt).length > 0;
+          if (is_redline) {
+            let j = i + 1;
+            let next_is_redline = false;
+            let temp_ins_count = Object.keys(active_ins).length;
+            let temp_del_count = Object.keys(active_del).length;
+            let temp_fmt_count = Object.keys(active_fmt).length;
+            while (j < items.length) {
+              const next_item = items[j];
+              if (next_item instanceof Run) {
+                if (!get_run_text(next_item)) {
+                  j++;
+                  continue;
+                }
+                if (temp_ins_count > 0 || temp_del_count > 0 || temp_fmt_count > 0) {
+                  next_is_redline = true;
+                }
+                break;
+              } else {
+                const ev = next_item;
+                if (ev.type === "ins_start") temp_ins_count++;
+                else if (ev.type === "ins_end") temp_ins_count = Math.max(0, temp_ins_count - 1);
+                else if (ev.type === "del_start") temp_del_count++;
+                else if (ev.type === "del_end") temp_del_count = Math.max(0, temp_del_count - 1);
+                else if (ev.type === "fmt_start") temp_fmt_count++;
+                else if (ev.type === "fmt_end") temp_fmt_count = Math.max(0, temp_fmt_count - 1);
+              }
+              j++;
+            }
+            if (next_is_redline) should_defer = true;
+          }
+          if (!should_defer && deferred_meta_states.length > 0) {
+            const meta_block = this._build_merged_meta_block(deferred_meta_states);
+            if (meta_block) {
+              flush_pending_runs();
+              current_wrappers = ["", ""];
+              current_style = ["", ""];
+              const full_meta = `{>>${meta_block}<<}`;
+              this._add_virtual_text(full_meta, current, paragraph);
+              current += full_meta.length;
+            }
+            deferred_meta_states = [];
+          }
+        }
+      } else {
+        const ev = item;
+        leading_strip_active = false;
+        flush_pending_runs();
+        current_wrappers = ["", ""];
+        current_style = ["", ""];
+        if (ev.type === "start") active_ids.add(ev.id);
+        else if (ev.type === "end") active_ids.delete(ev.id);
+        else if (ev.type === "ins_start") active_ins[ev.id] = ev;
+        else if (ev.type === "ins_end") delete active_ins[ev.id];
+        else if (ev.type === "del_start") active_del[ev.id] = ev;
+        else if (ev.type === "del_end") delete active_del[ev.id];
+        else if (ev.type === "fmt_start") active_fmt[ev.id] = ev;
+        else if (ev.type === "fmt_end") delete active_fmt[ev.id];
+        else if (ev.type === "footnote" || ev.type === "endnote") {
+          flush_pending_runs();
+          current_wrappers = ["", ""];
+          current_style = ["", ""];
+          const prefix_str = ev.type === "footnote" ? "fn" : "en";
+          const txt = `[^${prefix_str}-${ev.id}]`;
+          this._add_virtual_text(txt, current, paragraph);
+          current += txt.length;
+        } else if (ev.type === "hyperlink_start") {
+          flush_pending_runs();
+          current_wrappers = ["", ""];
+          current_style = ["", ""];
+          this._add_virtual_text("[", current, paragraph, ev.id);
+          current += 1;
+          active_hyperlink_id = ev.id;
+        } else if (ev.type === "hyperlink_end") {
+          flush_pending_runs();
+          current_wrappers = ["", ""];
+          current_style = ["", ""];
+          const txt = `](${ev.date})`;
+          this._add_virtual_text(txt, current, paragraph, ev.id);
+          current += txt.length;
+          active_hyperlink_id = null;
+        } else if (ev.type === "xref_start") {
+          flush_pending_runs();
+          current_wrappers = ["", ""];
+          current_style = ["", ""];
+          this._add_virtual_text("[~", current, paragraph);
+          current += 2;
+        } else if (ev.type === "xref_end") {
+          flush_pending_runs();
+          current_wrappers = ["", ""];
+          current_style = ["", ""];
+          const txt = `~](#${ev.id})`;
+          this._add_virtual_text(txt, current, paragraph);
+          current += txt.length;
+        } else if (ev.type === "bookmark") {
+          flush_pending_runs();
+          current_wrappers = ["", ""];
+          current_style = ["", ""];
+          const txt = `{#${ev.id}}`;
+          this._add_virtual_text(txt, current, paragraph);
+          current += txt.length;
+        }
+      }
+    }
+    flush_pending_runs();
+    if (deferred_meta_states.length > 0) {
+      const meta_block = this._build_merged_meta_block(deferred_meta_states);
+      if (meta_block) {
+        const full_meta = `{>>${meta_block}<<}`;
+        this._add_virtual_text(full_meta, current, paragraph);
+        current += full_meta.length;
+      }
+    }
+    return current;
+  }
+  _get_wrappers(ins_id, del_id, active_ids, active_fmt) {
+    if (del_id) return ["{--", "--}"];
+    if (ins_id) return ["{++", "++}"];
+    if (active_ids.size > 0 || Object.keys(active_fmt).length > 0) return ["{==", "==}"];
+    return ["", ""];
+  }
+  _build_merged_meta_block(states_list) {
+    const change_lines = [];
+    const comment_lines = [];
+    const seen_sigs = /* @__PURE__ */ new Set();
+    for (const [ins_map, del_map, comments_set, fmt_map] of states_list) {
+      for (const [uid, meta] of Object.entries(ins_map)) {
+        const sig = `Chg:${uid}`;
+        if (!seen_sigs.has(sig)) {
+          const auth = meta.author || "Unknown";
+          change_lines.push(`[${sig} insert] ${auth}`);
+          seen_sigs.add(sig);
+        }
+      }
+      for (const [uid, meta] of Object.entries(del_map)) {
+        const sig = `Chg:${uid}`;
+        if (!seen_sigs.has(sig)) {
+          const auth = meta.author || "Unknown";
+          change_lines.push(`[${sig} delete] ${auth}`);
+          seen_sigs.add(sig);
+        }
+      }
+      for (const [uid, meta] of Object.entries(fmt_map)) {
+        const sig = `Chg:${uid}`;
+        if (!seen_sigs.has(sig)) {
+          const auth = meta.author || "Unknown";
+          change_lines.push(`[${sig} format] ${auth}`);
+          seen_sigs.add(sig);
+        }
+      }
+      const sorted_ids = Array.from(comments_set).sort();
+      for (const c_id of sorted_ids) {
+        if (!this.comments_map[c_id]) continue;
+        const sig = `Com:${c_id}`;
+        if (!seen_sigs.has(sig)) {
+          const data = this.comments_map[c_id];
+          let header = `[${sig}] ${data.author}`;
+          if (data.date) header += ` @ ${data.date}`;
+          if (data.resolved) header += `(RESOLVED)`;
+          comment_lines.push(`${header}: ${data.text}`);
+          seen_sigs.add(sig);
+        }
+      }
+    }
+    return [...change_lines, ...comment_lines].join("\n");
+  }
+  _add_virtual_text(text, offset, context_paragraph, hyperlink_id = null) {
+    const span = {
+      start: offset,
+      end: offset + text.length,
+      text,
+      run: null,
+      paragraph: context_paragraph,
+      hyperlink_id: hyperlink_id || void 0
+    };
+    this.spans.push(span);
+    this._text_chunks.push(text);
+  }
+  _replace_smart_quotes(text) {
+    return text.replace(/“/g, '"').replace(/”/g, '"').replace(/‘/g, "'").replace(/’/g, "'");
+  }
+  _make_fuzzy_regex(target_text) {
+    target_text = this._strip_markdown_formatting(target_text);
+    target_text = this._replace_smart_quotes(target_text);
+    const parts = [];
+    const token_pattern = /(\[_+\])|(\s+)|(['"])|([.,;:\/])/g;
+    let last_idx = 0;
+    let match;
+    const escapeRegExp = (str) => str.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+    while ((match = token_pattern.exec(target_text)) !== null) {
+      const literal = target_text.substring(last_idx, match.index);
+      if (literal) parts.push(escapeRegExp(literal));
+      const g_placeholder = match[1];
+      const g_space = match[2];
+      const g_quote = match[3];
+      const g_punct = match[4];
+      if (g_placeholder) {
+        parts.push("\\[_+\\]");
+      } else if (g_space) {
+        parts.push("(?:\\*\\*|__|\\*|_)?");
+        parts.push("\\s+");
+        parts.push("(?:\\*\\*|__|\\*|_)?");
+      } else if (g_quote) {
+        if (g_quote === "'") parts.push("[\u2018\u2019']");
+        else parts.push('["\u201C\u201D]');
+      } else if (g_punct) {
+        parts.push("(?:\\*\\*|__|\\*|_)?");
+        parts.push(escapeRegExp(g_punct));
+        parts.push("(?:\\*\\*|__|\\*|_)?");
+      }
+      last_idx = token_pattern.lastIndex;
+    }
+    const remaining = target_text.substring(last_idx);
+    if (remaining) parts.push(escapeRegExp(remaining));
+    return parts.join("");
+  }
+  find_match_index(target_text) {
+    let start_idx = this.full_text.indexOf(target_text);
+    if (start_idx !== -1) return [start_idx, target_text.length];
+    const norm_full = this._replace_smart_quotes(this.full_text);
+    const norm_target = this._replace_smart_quotes(target_text);
+    start_idx = norm_full.indexOf(norm_target);
+    if (start_idx !== -1) return [start_idx, target_text.length];
+    const stripped_target = this._strip_markdown_formatting(target_text);
+    if (this.full_text.includes(stripped_target)) {
+      start_idx = this.full_text.indexOf(stripped_target);
+      return [start_idx, stripped_target.length];
+    }
+    try {
+      const pattern = new RegExp(this._make_fuzzy_regex(target_text));
+      const match = pattern.exec(this.full_text);
+      if (match) return [match.index, match[0].length];
+    } catch (e) {
+    }
+    return [-1, 0];
+  }
+  find_all_match_indices(target_text) {
+    if (!target_text) return [];
+    const escapeRegExp = (str) => str.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+    let matches = [...this.full_text.matchAll(new RegExp(escapeRegExp(target_text), "g"))];
+    if (matches.length > 0) return matches.map((m) => [m.index, m[0].length]);
+    const norm_full = this._replace_smart_quotes(this.full_text);
+    const norm_target = this._replace_smart_quotes(target_text);
+    matches = [...norm_full.matchAll(new RegExp(escapeRegExp(norm_target), "g"))];
+    if (matches.length > 0) return matches.map((m) => [m.index, m[0].length]);
+    const stripped_target = this._strip_markdown_formatting(target_text);
+    matches = [...this.full_text.matchAll(new RegExp(escapeRegExp(stripped_target), "g"))];
+    if (matches.length > 0) return matches.map((m) => [m.index, m[0].length]);
+    try {
+      const pattern = new RegExp(this._make_fuzzy_regex(target_text), "g");
+      matches = [...this.full_text.matchAll(pattern)];
+      if (matches.length > 0) return matches.map((m) => [m.index, m[0].length]);
+    } catch (e) {
+    }
+    return [];
+  }
+  find_target_runs(target_text) {
+    const [start_idx, length] = this.find_match_index(target_text);
+    if (start_idx === -1) return [];
+    return this._resolve_runs_at_range(start_idx, start_idx + length);
+  }
+  find_target_runs_by_index(start_index, length, rebuild_map = true) {
+    return this._resolve_runs_at_range(start_index, start_index + length, rebuild_map);
+  }
+  get_virtual_spans_in_range(start_index, length) {
+    const end_index = start_index + length;
+    return this.spans.filter((s) => s.run === null && s.text === "\n\n" && s.start >= start_index && s.end <= end_index);
+  }
+  _resolve_runs_at_range(start_idx, end_idx, rebuild_map = true) {
+    const affected_spans = this.spans.filter((s) => s.end > start_idx && s.start < end_idx);
+    if (affected_spans.length === 0) return [];
+    const working_runs = affected_spans.filter((s) => s.run !== null).map((s) => s.run);
+    if (working_runs.length === 0) return [];
+    let dom_modified = false;
+    const first_real_span = affected_spans.find((s) => s.run !== null);
+    let start_split_adjustment = 0;
+    if (first_real_span) {
+      const local_start = start_idx - first_real_span.start;
+      if (local_start > 0) {
+        const idx_in_working = 0;
+        const [, right_run] = this._split_run_at_index(working_runs[idx_in_working], local_start);
+        working_runs[idx_in_working] = right_run;
+        dom_modified = true;
+        start_split_adjustment = local_start;
+      }
+    }
+    const last_real_span = [...affected_spans].reverse().find((s) => s.run !== null);
+    if (last_real_span) {
+      const is_same_run = first_real_span === last_real_span;
+      const run_to_split = working_runs[working_runs.length - 1];
+      let overlap_end = Math.min(last_real_span.end, end_idx);
+      let local_end = overlap_end - last_real_span.start;
+      if (is_same_run && start_split_adjustment > 0) {
+        local_end -= start_split_adjustment;
+      }
+      const run_text = get_run_text(run_to_split);
+      if (local_end > 0 && local_end < run_text.length) {
+        const [left_run] = this._split_run_at_index(run_to_split, local_end);
+        working_runs[working_runs.length - 1] = left_run;
+        dom_modified = true;
+      }
+    }
+    if (dom_modified && rebuild_map) {
+      this._build_map();
+    }
+    return working_runs;
+  }
+  get_insertion_anchor(index, rebuild_map = true) {
+    const preceding = this.spans.filter((s) => s.end === index);
+    if (preceding.length > 0) {
+      for (let i = preceding.length - 1; i >= 0; i--) {
+        if (preceding[i].run) return [preceding[i].run, preceding[i].paragraph];
+      }
+      for (let i = preceding.length - 1; i >= 0; i--) {
+        if (preceding[i].paragraph) return [null, preceding[i].paragraph];
+      }
+    }
+    const containing = this.spans.filter((s) => s.start < index && index < s.end);
+    if (containing.length > 0) {
+      const span = containing[0];
+      if (span.run === null) {
+        if (span.paragraph === null) {
+          return this.get_insertion_anchor(span.end, rebuild_map);
+        }
+        return [null, span.paragraph];
+      } else {
+        const offset = index - span.start;
+        const [left] = this._split_run_at_index(span.run, offset);
+        if (rebuild_map) this._build_map();
+        return [left, span.paragraph];
+      }
+    }
+    if (index === 0 && this.spans.length > 0) {
+      for (const s of this.spans) if (s.run) return [s.run, s.paragraph];
+      for (const s of this.spans) if (s.paragraph) return [null, s.paragraph];
+      return [null, null];
+    }
+    const preceding_gap = this.spans.filter((s) => s.end < index);
+    if (preceding_gap.length > 0) {
+      for (let i = preceding_gap.length - 1; i >= 0; i--) {
+        if (preceding_gap[i].run) return [preceding_gap[i].run, preceding_gap[i].paragraph];
+      }
+      for (let i = preceding_gap.length - 1; i >= 0; i--) {
+        if (preceding_gap[i].paragraph) return [null, preceding_gap[i].paragraph];
+      }
+    }
+    return [null, null];
+  }
+  _split_run_at_index(run, split_index) {
+    const text = get_run_text(run);
+    const left_text = text.substring(0, split_index);
+    const right_text = text.substring(split_index);
+    this._set_run_text_elements(run._element, left_text);
+    const new_r_element = run._element.cloneNode(true);
+    this._set_run_text_elements(new_r_element, right_text);
+    if (run._element.parentNode) {
+      run._element.parentNode.insertBefore(new_r_element, run._element.nextSibling);
+    }
+    const new_run = new Run(new_r_element, run._parent);
+    return [run, new_run];
+  }
+  _set_run_text_elements(r_element, new_text) {
+    const to_remove = [];
+    for (let i = 0; i < r_element.childNodes.length; i++) {
+      const child = r_element.childNodes[i];
+      if (child.nodeType === 1 && ["w:t", "w:delText", "w:br", "w:cr", "w:tab"].includes(child.tagName)) {
+        to_remove.push(child);
+      }
+    }
+    for (const child of to_remove) {
+      r_element.removeChild(child);
+    }
+    const doc = r_element.ownerDocument;
+    if (doc) {
+      const new_t = doc.createElement("w:t");
+      new_t.textContent = new_text;
+      if (new_text.trim() !== new_text) {
+        new_t.setAttribute("xml:space", "preserve");
+      }
+      r_element.appendChild(new_t);
+    }
+  }
+  get_context_at_range(start_idx, end_idx) {
+    const real_spans = this.spans.filter((s) => s.run && s.end > start_idx && s.start < end_idx);
+    if (real_spans.length > 0) return real_spans[0];
+    return null;
+  }
+};
+
+// src/diff.ts
+var import_diff_match_patch = __toESM(require("diff-match-patch"), 1);
+function trim_common_context(target, new_val) {
+  if (!target || !new_val) return [0, 0];
+  const isSpace = (char) => /\s/.test(char);
+  let prefix_len = 0;
+  let limit = Math.min(target.length, new_val.length);
+  while (prefix_len < limit && target[prefix_len] === new_val[prefix_len]) {
+    prefix_len++;
+  }
+  if (prefix_len < target.length && prefix_len < new_val.length) {
+    while (prefix_len > 0) {
+      const target_split = !isSpace(target[prefix_len - 1]) && !isSpace(target[prefix_len]);
+      const new_split = !isSpace(new_val[prefix_len - 1]) && !isSpace(new_val[prefix_len]);
+      if (target_split || new_split) {
+        prefix_len--;
+      } else {
+        break;
+      }
+    }
+  }
+  while (prefix_len > 0) {
+    if (prefix_len < target.length) {
+      const charSeq = target.substring(prefix_len - 1, prefix_len + 1);
+      if (charSeq === "**" || charSeq === "__") {
+        prefix_len--;
+        continue;
+      }
+    }
+    const left = target.substring(0, prefix_len);
+    const b_count = (left.match(/\*\*/g) || []).length;
+    const u2_count = (left.match(/__/g) || []).length;
+    const u1_count = (left.replace(/__/g, "").match(/_/g) || []).length;
+    if (b_count % 2 !== 0) {
+      prefix_len = left.lastIndexOf("**");
+      continue;
+    }
+    if (u2_count % 2 !== 0) {
+      prefix_len = left.lastIndexOf("__");
+      continue;
+    }
+    if (u1_count % 2 !== 0) {
+      let idx = left.length - 1;
+      while (idx >= 0) {
+        if (left[idx] === "_" && (idx === 0 || left[idx - 1] !== "_") && (idx === left.length - 1 || left[idx + 1] !== "_")) {
+          prefix_len = idx;
+          break;
+        }
+        idx--;
+      }
+      continue;
+    }
+    let temp_len = prefix_len;
+    let hit_header = false;
+    while (temp_len > 0) {
+      const char = target[temp_len - 1];
+      if (char === "#") {
+        prefix_len = temp_len - 1;
+        while (prefix_len > 0 && target[prefix_len - 1] !== "\n") {
+          prefix_len--;
+        }
+        hit_header = true;
+        break;
+      }
+      if (char === "\n") break;
+      temp_len--;
+    }
+    if (hit_header) continue;
+    break;
+  }
+  let suffix_len = 0;
+  const target_rem_len = target.length - prefix_len;
+  const new_rem_len = new_val.length - prefix_len;
+  const limit_suffix = Math.min(target_rem_len, new_rem_len);
+  while (suffix_len < limit_suffix && target[target.length - 1 - suffix_len] === new_val[new_val.length - 1 - suffix_len]) {
+    suffix_len++;
+  }
+  if (suffix_len > 0) {
+    while (suffix_len > 0) {
+      let target_split = false;
+      if (suffix_len < target.length) {
+        target_split = !isSpace(target[target.length - 1 - suffix_len]) && !isSpace(target[target.length - suffix_len]);
+      }
+      let new_split = false;
+      if (suffix_len < new_val.length) {
+        new_split = !isSpace(new_val[new_val.length - 1 - suffix_len]) && !isSpace(new_val[new_val.length - suffix_len]);
+      }
+      if (target_split || new_split) {
+        suffix_len--;
+      } else {
+        break;
+      }
+    }
+  }
+  while (suffix_len > 0) {
+    const idx = target.length - suffix_len;
+    if (idx > 0) {
+      const charSeq = target.substring(idx - 1, idx + 1);
+      if (charSeq === "**" || charSeq === "__") {
+        suffix_len--;
+        continue;
+      }
+    }
+    const right = target.substring(target.length - suffix_len);
+    const b_count = (right.match(/\*\*/g) || []).length;
+    const u2_count = (right.match(/__/g) || []).length;
+    const u1_count = (right.replace(/__/g, "").match(/_/g) || []).length;
+    if (b_count % 2 !== 0) {
+      suffix_len -= right.indexOf("**") + 2;
+      continue;
+    }
+    if (u2_count % 2 !== 0) {
+      suffix_len -= right.indexOf("__") + 2;
+      continue;
+    }
+    if (u1_count % 2 !== 0) {
+      let idx_in_right = 0;
+      while (idx_in_right < right.length) {
+        if (right[idx_in_right] === "_" && (idx_in_right === 0 || right[idx_in_right - 1] !== "_") && (idx_in_right === right.length - 1 || right[idx_in_right + 1] !== "_")) {
+          suffix_len -= idx_in_right + 1;
+          break;
+        }
+        idx_in_right++;
+      }
+      continue;
+    }
+    break;
+  }
+  if (suffix_len > 0 && /^\s+$/.test(target.substring(target.length - suffix_len))) {
+    suffix_len = 0;
+  }
+  for (const marker of ["**", "__", "_"]) {
+    const mlen = marker.length;
+    const tgt_rem = target.substring(prefix_len, target.length - suffix_len);
+    const new_rem = new_val.substring(prefix_len, new_val.length - suffix_len);
+    if (tgt_rem.startsWith(marker) && new_rem.startsWith(marker) && tgt_rem.endsWith(marker) && new_rem.endsWith(marker) && tgt_rem.length >= 2 * mlen && new_rem.length >= 2 * mlen) {
+      prefix_len += mlen;
+      suffix_len += mlen;
+    }
+  }
+  return [prefix_len, suffix_len];
+}
+function _words_to_chars(text1, text2) {
+  const token_array = [];
+  const token_hash = {};
+  const split_pattern = /(\s+|[\p{L}\p{N}_]+|[^\p{L}\p{N}_\s])/gu;
+  const encode_text = (text) => {
+    const tokens = text.split(split_pattern).filter(Boolean);
+    let encoded_chars = "";
+    for (const token of tokens) {
+      if (token in token_hash) {
+        encoded_chars += String.fromCharCode(token_hash[token]);
+      } else {
+        const code = token_array.length;
+        token_hash[token] = code;
+        token_array.push(token);
+        encoded_chars += String.fromCharCode(code);
+      }
+    }
+    return encoded_chars;
+  };
+  return [encode_text(text1), encode_text(text2), token_array];
+}
+function generate_edits_from_text(original_text, modified_text) {
+  const dmp = new import_diff_match_patch.default.diff_match_patch();
+  const [chars1, chars2, token_array] = _words_to_chars(original_text, modified_text);
+  const diffs = dmp.diff_main(chars1, chars2, false);
+  dmp.diff_cleanupSemantic(diffs);
+  for (let i = 0; i < diffs.length; i++) {
+    const chars = diffs[i][1];
+    let text = "";
+    for (let j = 0; j < chars.length; j++) text += token_array[chars.charCodeAt(j)];
+    diffs[i][1] = text;
+  }
+  const edits = [];
+  let current_original_index = 0;
+  let pending_delete = null;
+  for (const [op, text] of diffs) {
+    if (op === 0) {
+      if (pending_delete) {
+        const [idx, del_txt] = pending_delete;
+        edits.push({ type: "modify", target_text: del_txt, new_text: "", comment: "Diff: Text deleted", _match_start_index: idx });
+        pending_delete = null;
+      }
+      current_original_index += text.length;
+    } else if (op === -1) {
+      pending_delete = [current_original_index, text];
+      current_original_index += text.length;
+    } else if (op === 1) {
+      if (pending_delete) {
+        const [idx, del_txt] = pending_delete;
+        edits.push({ type: "modify", target_text: del_txt, new_text: text, comment: "Diff: Replacement", _match_start_index: idx });
+        pending_delete = null;
+      } else {
+        edits.push({ type: "modify", target_text: "", new_text: text, comment: "Diff: Text inserted", _match_start_index: current_original_index });
+      }
+    }
+  }
+  if (pending_delete) {
+    const [idx, del_txt] = pending_delete;
+    edits.push({ type: "modify", target_text: del_txt, new_text: "", comment: "Diff: Text deleted", _match_start_index: idx });
+  }
+  return edits;
+}
+
+// src/engine.ts
+function insertAfter(newNode, refNode) {
+  if (refNode.parentNode) {
+    refNode.parentNode.insertBefore(newNode, refNode.nextSibling);
+  }
+}
+var BatchValidationError = class extends Error {
+  errors;
+  constructor(errors) {
+    super("Batch validation failed:\n" + errors.join("\n"));
+    this.name = "BatchValidationError";
+    this.errors = errors;
+  }
+};
+function validate_edit_strings(edits) {
+  const errors = [];
+  for (let i = 0; i < edits.length; i++) {
+    const edit = edits[i];
+    const t_text = edit.target_text || "";
+    const n_text = edit.new_text || "";
+    if (n_text.includes("{++") || n_text.includes("{--") || n_text.includes("{>>") || n_text.includes("{==")) {
+      errors.push(`- Edit ${i + 1} Failed: Do not manually write CriticMarkup tags ({++, {--, {>>, {==) in \`new_text\`. The engine handles redlining automatically. To add a comment, use the \`comment\` parameter.`);
+    }
+    if (t_text.includes("[^") || n_text.includes("[^")) {
+      const t_fns = (t_text.match(/\[\^(?:fn|en)-[^\]]+\]/g) || []).sort();
+      const n_fns = (n_text.match(/\[\^(?:fn|en)-[^\]]+\]/g) || []).sort();
+      if (JSON.stringify(t_fns) !== JSON.stringify(n_fns)) {
+        if (n_fns.length > t_fns.length || n_fns.some((f) => n_fns.filter((x) => x === f).length > t_fns.filter((x) => x === f).length)) {
+          errors.push(`- Edit ${i + 1} Failed: Cannot insert footnote/endnote markers via text replace. Markers like \`[^fn-N]\` are read-only projections. Use Word's References menu.`);
+        } else {
+          errors.push(`- Edit ${i + 1} Failed: Cannot delete footnote/endnote references via text replace. The marker corresponds to a structural XML element.`);
+        }
+      }
+    }
+    if (t_text.includes("](") || n_text.includes("](")) {
+      const t_links = (t_text.match(/\[(?!~)[^\]]+\]\([^)]+\)/g) || []).sort();
+      const n_links = (n_text.match(/\[(?!~)[^\]]+\]\([^)]+\)/g) || []).sort();
+      if (t_links.length !== n_links.length) {
+        if (n_links.length > t_links.length) {
+          errors.push(`- Edit ${i + 1} Failed: Cannot insert hyperlinks via text replace. Use a dedicated structural operation.`);
+        } else {
+          errors.push(`- Edit ${i + 1} Failed: Cannot delete hyperlinks via text replace. The marker corresponds to a structural XML element.`);
+        }
+      } else if (t_links.length > 1 && JSON.stringify(t_links) !== JSON.stringify(n_links)) {
+        errors.push(`- Edit ${i + 1} Failed: Can only edit or retarget one hyperlink per text replacement. Please split into multiple edits.`);
+      }
+    }
+    if (t_text.includes("[~") || n_text.includes("[~")) {
+      const t_xrefs = t_text.match(/\[~[^~]+~\]\(#[^\)]+\)/g) || [];
+      const n_xrefs = n_text.match(/\[~[^~]+~\]\(#[^\)]+\)/g) || [];
+      if (t_xrefs.length !== n_xrefs.length) {
+        if (n_xrefs.length > t_xrefs.length) {
+          errors.push(`- Edit ${i + 1} Failed: Cannot insert cross-references via text replace. Markers are read-only projections.`);
+        } else {
+          errors.push(`- Edit ${i + 1} Failed: Cannot delete cross-references via text replace. The marker corresponds to a structural XML element.`);
+        }
+      } else {
+        if (JSON.stringify(t_xrefs) !== JSON.stringify(n_xrefs)) {
+          errors.push(`- Edit ${i + 1} Failed: Modifying or retargeting cross-reference markers is disallowed to prevent dependency corruption.`);
+        }
+      }
+    }
+    if (t_text.includes("{#") || n_text.includes("{#")) {
+      const t_anchors = t_text.match(/\{#[^\}]+\}/g) || [];
+      const n_anchors = n_text.match(/\{#[^\}]+\}/g) || [];
+      for (const a of n_anchors) {
+        if (n_anchors.filter((x) => x === a).length > t_anchors.filter((x) => x === a).length) {
+          errors.push(`- Edit ${i + 1} Failed: Cannot modify or insert internal anchor markers (\`{#...}\`). These represent structural XML bookmarks.`);
+          break;
+        }
+      }
+    }
+    if (edit.type === "modify" && n_text) {
+      const lines = n_text.split("\n");
+      for (const line of lines) {
+        const stripped = line.trimStart();
+        if (stripped.startsWith("#######")) {
+          const level = stripped.length - stripped.replace(/^#+/, "").length;
+          if (stripped.substring(level).startsWith(" ") || stripped.substring(level) === "") {
+            errors.push(`- Edit ${i + 1} Failed: Heading level ${level} is not supported (maximum is 6).`);
+            break;
+          }
+        }
+      }
+    }
+    if (t_text.includes("READONLY_BOUNDARY_START") || n_text.includes("READONLY_BOUNDARY_START") || t_text.includes("# Document Structure (Read-Only)") || n_text.includes("# Document Structure (Read-Only)")) {
+      errors.push(`- Edit ${i + 1} Failed: Modification targets the read-only boundary (Structural Appendix). This section cannot be edited.`);
+    }
+  }
+  return errors;
+}
+var RedlineEngine = class {
+  doc;
+  author;
+  timestamp;
+  current_id;
+  mapper;
+  comments_manager;
+  clean_mapper = null;
+  skipped_details = [];
+  constructor(doc, author = "Adeu AI (TS)") {
+    this.doc = doc;
+    this.author = author;
+    this.timestamp = (/* @__PURE__ */ new Date()).toISOString().replace(/\.\d{3}Z$/, "Z");
+    const w16du_ns = "http://schemas.microsoft.com/office/word/2023/wordml/word16du";
+    for (const part of this.doc.pkg.parts) {
+      if (part === this.doc.part || part.contentType.includes("wordprocessingml") && part.contentType.endsWith("+xml")) {
+        if (!part._element.hasAttribute("xmlns:w16du")) {
+          part._element.setAttribute("xmlns:w16du", w16du_ns);
+        }
+      }
+    }
+    this.current_id = this._scan_existing_ids();
+    this.mapper = new DocumentMapper(this.doc);
+    this.comments_manager = new CommentsManager(this.doc);
+  }
+  _scan_existing_ids() {
+    let maxId = 0;
+    for (const tag of ["w:ins", "w:del"]) {
+      const elements = findAllDescendants(this.doc.element, tag);
+      for (const el of elements) {
+        const val = parseInt(el.getAttribute("w:id") || "0", 10);
+        if (!isNaN(val) && val > maxId) maxId = val;
+      }
+    }
+    return maxId;
+  }
+  accept_all_revisions() {
+    const dels = findAllDescendants(this.doc.element, "w:del");
+    for (const d of dels) {
+      const parent = d.parentNode;
+      if (parent?.tagName === "w:trPr") {
+        const tr = parent.parentNode;
+        tr?.parentNode?.removeChild(tr);
+      } else {
+        parent?.removeChild(d);
+      }
+    }
+    const insNodes = findAllDescendants(this.doc.element, "w:ins");
+    for (const i of insNodes) {
+      const parent = i.parentNode;
+      if (parent?.tagName === "w:trPr") {
+        parent.removeChild(i);
+      } else {
+        while (i.firstChild) parent?.insertBefore(i.firstChild, i);
+        parent?.removeChild(i);
+      }
+    }
+  }
+  _getNextId() {
+    this.current_id++;
+    return this.current_id.toString();
+  }
+  _create_track_change_tag(tagName, author = "", reuseId = null) {
+    const xmlDoc = this.doc.part._element.ownerDocument;
+    const tag = xmlDoc.createElement(tagName);
+    const wid = reuseId !== null ? reuseId : this._getNextId();
+    tag.setAttribute("w:id", wid);
+    tag.setAttribute("w:author", author || this.author);
+    tag.setAttribute("w:date", this.timestamp);
+    tag.setAttribute("w16du:dateUtc", this.timestamp);
+    return tag;
+  }
+  _set_text_content(element, text) {
+    element.textContent = text;
+    if (text.trim() !== text) {
+      element.setAttribute("xml:space", "preserve");
+    }
+  }
+  _parse_markdown_style(text) {
+    const stripped_text = text.trimStart();
+    if (stripped_text.startsWith("#")) {
+      let level = 0;
+      let temp = stripped_text;
+      while (temp.startsWith("#")) {
+        level++;
+        temp = temp.substring(1);
+      }
+      if (temp.startsWith(" ")) return [temp.trim(), `Heading ${level}`];
+    }
+    if (stripped_text.startsWith("* ") || stripped_text.startsWith("- ")) {
+      return [stripped_text.substring(2).trim(), "List Paragraph"];
+    }
+    const match = stripped_text.match(/^\d+\.\s+/);
+    if (match) {
+      return [stripped_text.substring(match[0].length).trim(), "List Number"];
+    }
+    return [text, null];
+  }
+  _parse_inline_markdown(text, baseStyle = {}) {
+    if (!text) return [];
+    const tokenPattern = /(\*\*.*?\*\*)|(_.*?_)/;
+    const match = text.match(tokenPattern);
+    if (!match) return [[text, baseStyle]];
+    const start = match.index;
+    const raw = match[0];
+    const end = start + raw.length;
+    const isBold = raw.startsWith("**");
+    const innerContent = isBold ? raw.substring(2, raw.length - 2) : raw.substring(1, raw.length - 1);
+    const preText = text.substring(0, start);
+    const postText = text.substring(end);
+    const results = [];
+    if (preText) results.push([preText, baseStyle]);
+    const newStyle = { ...baseStyle };
+    if (isBold) newStyle.bold = true;
+    else newStyle.italic = true;
+    results.push(...this._parse_inline_markdown(innerContent, newStyle));
+    results.push(...this._parse_inline_markdown(postText, baseStyle));
+    return results;
+  }
+  _apply_run_props(runElement, props, suppressInherited = false) {
+    if (!props) {
+      if (!suppressInherited) return;
+      props = {};
+    }
+    let rPr = findChild(runElement, "w:rPr");
+    if (!rPr && (props.bold || props.italic || suppressInherited)) {
+      const doc = runElement.ownerDocument;
+      rPr = doc.createElement("w:rPr");
+      runElement.appendChild(rPr);
+    }
+    if (rPr) {
+      const doc = runElement.ownerDocument;
+      if (props.bold) {
+        let b = findChild(rPr, "w:b");
+        if (!b) {
+          b = doc.createElement("w:b");
+          rPr.appendChild(b);
+        }
+        b.setAttribute("w:val", "1");
+      } else if (suppressInherited) {
+        const b = findChild(rPr, "w:b");
+        if (b) rPr.removeChild(b);
+      }
+      if (props.italic) {
+        let i = findChild(rPr, "w:i");
+        if (!i) {
+          i = doc.createElement("w:i");
+          rPr.appendChild(i);
+        }
+        i.setAttribute("w:val", "1");
+      } else if (suppressInherited) {
+        const i = findChild(rPr, "w:i");
+        if (i) rPr.removeChild(i);
+      }
+    }
+  }
+  validate_edits(edits) {
+    const errors = [];
+    if (!this.mapper.full_text) this.mapper["_build_map"]();
+    errors.push(...validate_edit_strings(edits));
+    for (let i = 0; i < edits.length; i++) {
+      const edit = edits[i];
+      if (!edit.target_text) continue;
+      let matches = this.mapper.find_all_match_indices(edit.target_text);
+      let activeText = this.mapper.full_text;
+      if (matches.length === 0) {
+        if (!this.clean_mapper) this.clean_mapper = new DocumentMapper(this.doc, true);
+        matches = this.clean_mapper.find_all_match_indices(edit.target_text);
+        if (matches.length > 0) activeText = this.clean_mapper.full_text;
+      }
+      if (matches.length === 0) {
+        errors.push(`- Edit ${i + 1} Failed: Target text not found in document:
+  "${edit.target_text}"`);
+      } else if (matches.length > 1) {
+        errors.push(`- Edit ${i + 1} Failed: Target text is ambiguous. Found ${matches.length} matches.
+Provide more context.`);
+      }
+      for (const [start, length] of matches) {
+        const spans = this.mapper.spans.filter((s) => s.end > start && s.start < start + length);
+        const nestedAuthors = /* @__PURE__ */ new Set();
+        for (const s of spans) {
+          if (s.ins_id) {
+            const insNodes = findAllDescendants(this.doc.element, "w:ins").filter((n) => n.getAttribute("w:id") === s.ins_id);
+            if (insNodes.length > 0) {
+              const auth = insNodes[0].getAttribute("w:author");
+              if (auth && auth !== this.author) nestedAuthors.add(auth);
+            }
+          }
+        }
+        if (nestedAuthors.size > 0) {
+          errors.push(`- Edit ${i + 1} Failed: Modification targets an active insertion from another author (${Array.from(nestedAuthors).join(", ")}).`);
+        }
+      }
+    }
+    return errors;
+  }
+  process_batch(changes) {
+    this.skipped_details = [];
+    const actions = changes.filter((c) => ["accept", "reject", "reply"].includes(c.type));
+    const edits = changes.filter((c) => !["accept", "reject", "reply"].includes(c.type));
+    let applied_actions = 0, skipped_actions = 0;
+    if (actions.length > 0) {
+      const res = this.apply_review_actions(actions);
+      applied_actions = res[0];
+      skipped_actions = res[1];
+      if (applied_actions > 0) {
+        this.mapper["_build_map"]();
+        if (this.clean_mapper) this.clean_mapper["_build_map"]();
+      }
+    }
+    if (edits.length > 0) {
+      const errors = this.validate_edits(edits);
+      if (errors.length > 0) throw new BatchValidationError(errors);
+    }
+    let applied_edits = 0, skipped_edits = 0;
+    if (edits.length > 0) {
+      const res = this.apply_edits(edits);
+      applied_edits = res[0];
+      skipped_edits = res[1];
+    }
+    return {
+      actions_applied: applied_actions,
+      actions_skipped: skipped_actions,
+      edits_applied: applied_edits,
+      edits_skipped: skipped_edits,
+      skipped_details: this.skipped_details
+    };
+  }
+  apply_edits(edits) {
+    let applied = 0;
+    let skipped = 0;
+    const resolved_edits = [];
+    for (const edit of edits) {
+      if (edit._match_start_index !== void 0 && edit._match_start_index !== null) {
+        resolved_edits.push([edit, edit.new_text || null]);
+      } else if (edit.type === "insert_row" || edit.type === "delete_row") {
+        const [idx] = this.mapper.find_match_index(edit.target_text);
+        if (idx !== -1) {
+          edit._match_start_index = idx;
+          resolved_edits.push([edit, null]);
+        } else {
+          skipped++;
+          this.skipped_details.push(`- Failed to locate row target: '${(edit.target_text || "").substring(0, 40)}...'`);
+        }
+      } else {
+        const resolved = this._pre_resolve_heuristic_edit(edit);
+        if (resolved) {
+          if (Array.isArray(resolved)) {
+            for (const r of resolved) resolved_edits.push([r, r.new_text]);
+          } else {
+            resolved_edits.push([resolved, resolved.new_text]);
+          }
+        } else {
+          skipped++;
+          this.skipped_details.push(`- Failed to apply edit targeting: '${(edit.target_text || "insertion").substring(0, 40)}...'`);
+        }
+      }
+    }
+    resolved_edits.sort((a, b) => (b[0]._match_start_index || 0) - (a[0]._match_start_index || 0));
+    const occupied_ranges = [];
+    for (const [edit, orig_new] of resolved_edits) {
+      const start = edit._match_start_index || 0;
+      const end = start + (edit.target_text ? edit.target_text.length : 0);
+      const overlaps = occupied_ranges.some(([occ_start, occ_end]) => start < occ_end && end > occ_start);
+      if (overlaps) {
+        skipped++;
+        this.skipped_details.push(`- Skipped overlapping edit targeting: '${(edit.target_text || "insertion").substring(0, 40)}...'`);
+        continue;
+      }
+      let success = false;
+      if (edit.type === "modify") {
+        success = this._apply_single_edit_indexed(edit, orig_new, false);
+      } else if (edit.type === "insert_row" || edit.type === "delete_row") {
+        success = this._apply_table_edit(edit, false);
+      }
+      if (success) {
+        applied++;
+        occupied_ranges.push([start, end]);
+      } else {
+        skipped++;
+        this.skipped_details.push(`- Failed to apply edit targeting: '${(edit.target_text || "insertion").substring(0, 40)}...'`);
+      }
+    }
+    return [applied, skipped];
+  }
+  apply_review_actions(actions) {
+    let applied = 0;
+    let skipped = 0;
+    for (const action of actions) {
+      const type = action.type;
+      if (type === "reply") {
+        const cid = action.target_id.replace("Com:", "");
+        this.comments_manager.addComment(this.author, action.text, cid);
+        applied++;
+        continue;
+      }
+      const target_id = action.target_id.replace("Chg:", "");
+      const all_ins = findAllDescendants(this.doc.element, "w:ins").filter((n) => n.getAttribute("w:id") === target_id);
+      const all_del = findAllDescendants(this.doc.element, "w:del").filter((n) => n.getAttribute("w:id") === target_id);
+      const all_nodes = [...all_ins, ...all_del];
+      if (all_nodes.length === 0) {
+        skipped++;
+        this.skipped_details.push(`- Failed to apply action: Target ID ${action.target_id} not found.`);
+        continue;
+      }
+      for (const node of all_nodes) {
+        const is_ins = node.tagName === "w:ins";
+        const parent_tag = node.parentNode ? node.parentNode.tagName : "";
+        const is_trPr = parent_tag === "w:trPr";
+        if (type === "accept") {
+          if (is_ins) {
+            if (is_trPr) node.parentNode?.removeChild(node);
+            else {
+              while (node.firstChild) node.parentNode?.insertBefore(node.firstChild, node);
+              node.parentNode?.removeChild(node);
+            }
+          } else {
+            if (is_trPr) {
+              const tr = node.parentNode?.parentNode;
+              tr?.parentNode?.removeChild(tr);
+            } else {
+              node.parentNode?.removeChild(node);
+            }
+          }
+        } else if (type === "reject") {
+          if (is_ins) {
+            if (is_trPr) {
+              const tr = node.parentNode?.parentNode;
+              tr?.parentNode?.removeChild(tr);
+            } else node.parentNode?.removeChild(node);
+          } else {
+            if (is_trPr) node.parentNode?.removeChild(node);
+            else {
+              const delTexts = Array.from(node.getElementsByTagName("w:delText"));
+              for (const dt of delTexts) {
+                const t = dt.ownerDocument.createElement("w:t");
+                t.textContent = dt.textContent;
+                if (dt.hasAttribute("xml:space")) t.setAttribute("xml:space", "preserve");
+                dt.parentNode?.replaceChild(t, dt);
+              }
+              while (node.firstChild) node.parentNode?.insertBefore(node.firstChild, node);
+              node.parentNode?.removeChild(node);
+            }
+          }
+        }
+      }
+      applied++;
+    }
+    return [applied, skipped];
+  }
+  _apply_table_edit(edit, rebuild_map) {
+    const start_idx = edit._match_start_index || 0;
+    const [anchor_run, anchor_para] = this.mapper.get_insertion_anchor(start_idx, rebuild_map);
+    let target_element = null;
+    if (anchor_run) target_element = anchor_run._element;
+    else if (anchor_para) target_element = anchor_para._element;
+    if (!target_element) return false;
+    let tr = target_element;
+    while (tr && tr.tagName !== "w:tr") tr = tr.parentNode;
+    if (!tr) return false;
+    if (edit.type === "delete_row") {
+      let trPr = findChild(tr, "w:trPr");
+      if (!trPr) {
+        trPr = tr.ownerDocument.createElement("w:trPr");
+        tr.insertBefore(trPr, tr.firstChild);
+      }
+      trPr.appendChild(this._create_track_change_tag("w:del"));
+      return true;
+    } else if (edit.type === "insert_row") {
+      const new_tr = tr.ownerDocument.createElement("w:tr");
+      const trPr = tr.ownerDocument.createElement("w:trPr");
+      new_tr.appendChild(trPr);
+      trPr.appendChild(this._create_track_change_tag("w:ins"));
+      for (const cellText of edit.cells) {
+        const tc = tr.ownerDocument.createElement("w:tc");
+        const p = tr.ownerDocument.createElement("w:p");
+        const r = tr.ownerDocument.createElement("w:r");
+        const t = tr.ownerDocument.createElement("w:t");
+        t.textContent = cellText;
+        if (cellText.trim() !== cellText) t.setAttribute("xml:space", "preserve");
+        r.appendChild(t);
+        p.appendChild(r);
+        tc.appendChild(p);
+        new_tr.appendChild(tc);
+      }
+      if (edit.position === "above") tr.parentNode?.insertBefore(new_tr, tr);
+      else insertAfter(new_tr, tr);
+      return true;
+    }
+    return false;
+  }
+  _pre_resolve_heuristic_edit(edit) {
+    if (!edit.target_text) return null;
+    let [start_idx, match_len] = this.mapper.find_match_index(edit.target_text);
+    let use_clean_map = false;
+    if (start_idx === -1) {
+      if (!this.clean_mapper) this.clean_mapper = new DocumentMapper(this.doc, true);
+      [start_idx, match_len] = this.clean_mapper.find_match_index(edit.target_text);
+      if (start_idx !== -1) use_clean_map = true;
+      else return null;
+    }
+    const active_mapper = use_clean_map ? this.clean_mapper : this.mapper;
+    const effective_new_text = edit.new_text || "";
+    const actual_doc_text = this.mapper.full_text.substring(start_idx, start_idx + match_len);
+    if (actual_doc_text === effective_new_text || edit.target_text === effective_new_text) {
+      return {
+        type: "modify",
+        target_text: actual_doc_text,
+        new_text: actual_doc_text,
+        comment: edit.comment,
+        _match_start_index: start_idx,
+        _internal_op: "COMMENT_ONLY",
+        _active_mapper_ref: active_mapper
+      };
+    }
+    let effective_op = "";
+    let final_target = "";
+    let final_new = "";
+    let effective_start_idx = start_idx;
+    if (effective_new_text.startsWith(actual_doc_text)) {
+      effective_op = "INSERTION";
+      final_new = effective_new_text.substring(actual_doc_text.length);
+      effective_start_idx = start_idx + match_len;
+    } else {
+      const [prefix_len, suffix_len] = trim_common_context(actual_doc_text, effective_new_text);
+      const t_end = actual_doc_text.length - suffix_len;
+      const n_end = effective_new_text.length - suffix_len;
+      final_target = actual_doc_text.substring(prefix_len, t_end);
+      final_new = effective_new_text.substring(prefix_len, n_end);
+      effective_start_idx = start_idx + prefix_len;
+      if (!final_target && final_new) effective_op = "INSERTION";
+      else if (final_target && !final_new) effective_op = "DELETION";
+      else if (final_target && final_new) effective_op = "MODIFICATION";
+      else effective_op = "COMMENT_ONLY";
+    }
+    return {
+      type: "modify",
+      target_text: final_target,
+      new_text: final_new,
+      comment: edit.comment,
+      _match_start_index: effective_start_idx,
+      _internal_op: effective_op,
+      _active_mapper_ref: active_mapper
+    };
+  }
+  _apply_single_edit_indexed(edit, orig_new, rebuild_map) {
+    let op = edit._internal_op;
+    const active_mapper = edit._active_mapper_ref || this.mapper;
+    const start_idx = edit._match_start_index || 0;
+    const length = edit.target_text ? edit.target_text.length : 0;
+    const del_id = ["DELETION", "MODIFICATION"].includes(op) ? this._getNextId() : null;
+    const ins_id = ["INSERTION", "MODIFICATION"].includes(op) ? this._getNextId() : null;
+    if (op === "COMMENT_ONLY") {
+      return true;
+    }
+    if (op === "INSERTION") {
+      const [anchor_run, anchor_para] = active_mapper.get_insertion_anchor(start_idx, rebuild_map);
+      if (!anchor_run && !anchor_para) return false;
+      const xmlDoc = this.doc.part._element.ownerDocument;
+      const ins = this._create_track_change_tag("w:ins", "", ins_id);
+      const segments = this._parse_inline_markdown(edit.new_text || "");
+      for (const [segText, segProps] of segments) {
+        const r = xmlDoc.createElement("w:r");
+        this._apply_run_props(r, segProps, false);
+        const t = xmlDoc.createElement("w:t");
+        this._set_text_content(t, segText);
+        r.appendChild(t);
+        ins.appendChild(r);
+      }
+      if (anchor_run) {
+        insertAfter(ins, anchor_run._element);
+      } else if (anchor_para) {
+        anchor_para._element.appendChild(ins);
+      }
+      return true;
+    }
+    const target_runs = active_mapper.find_target_runs_by_index(start_idx, length, rebuild_map);
+    if (target_runs.length === 0) return false;
+    let last_del = null;
+    for (const run of target_runs) {
+      const del_tag = this._create_track_change_tag("w:del", "", del_id);
+      const new_run = run._element.cloneNode(true);
+      const tNodes = Array.from(new_run.getElementsByTagName("w:t"));
+      tNodes.forEach((t) => {
+        const delText = new_run.ownerDocument.createElement("w:delText");
+        delText.textContent = t.textContent;
+        if (t.hasAttribute("xml:space")) delText.setAttribute("xml:space", "preserve");
+        new_run.replaceChild(delText, t);
+      });
+      del_tag.appendChild(new_run);
+      run._element.parentNode?.replaceChild(del_tag, run._element);
+      last_del = del_tag;
+    }
+    if (op === "MODIFICATION" && edit.new_text && last_del) {
+      const xmlDoc = this.doc.part._element.ownerDocument;
+      const ins = this._create_track_change_tag("w:ins", "", ins_id);
+      const segments = this._parse_inline_markdown(edit.new_text);
+      for (const [segText, segProps] of segments) {
+        const r = xmlDoc.createElement("w:r");
+        this._apply_run_props(r, segProps, false);
+        const t = xmlDoc.createElement("w:t");
+        this._set_text_content(t, segText);
+        r.appendChild(t);
+        ins.appendChild(r);
+      }
+      insertAfter(ins, last_del);
+    }
+    return true;
+  }
+};
+
+// src/markup.ts
+function _should_strip_markers(text, marker) {
+  if (!text.startsWith(marker) || !text.endsWith(marker)) return false;
+  if (text.length < marker.length * 2) return false;
+  const inner = text.substring(marker.length, text.length - marker.length);
+  if (!inner) return false;
+  if (inner.includes(marker)) return false;
+  if (!/[a-zA-Z]/.test(inner)) return false;
+  if (marker === "__" && /^\w+$/.test(inner)) return false;
+  if (marker === "_") {
+    if (inner.includes("_")) return false;
+    if (/^[0-9_]+$/.test(inner)) return false;
+  }
+  return true;
+}
+function _strip_balanced_markers(text) {
+  let prefix_markup = "";
+  let suffix_markup = "";
+  let clean_text = text;
+  const markers = ["**", "__", "_", "*"];
+  for (const marker of markers) {
+    if (_should_strip_markers(clean_text, marker)) {
+      prefix_markup += marker;
+      suffix_markup = marker + suffix_markup;
+      clean_text = clean_text.substring(marker.length, clean_text.length - marker.length);
+      break;
+    }
+  }
+  return [prefix_markup, clean_text, suffix_markup];
+}
+function _replace_smart_quotes(text) {
+  return text.replace(/“/g, '"').replace(/”/g, '"').replace(/‘/g, "'").replace(/’/g, "'");
+}
+function _find_safe_boundaries(text, start, end) {
+  let new_start = start;
+  let new_end = end;
+  const expand_if_unbalanced = (marker) => {
+    const current_match = text.substring(new_start, new_end);
+    const count = (current_match.match(new RegExp(marker.replace(/\*/g, "\\*"), "g")) || []).length;
+    if (count % 2 !== 0) {
+      const suffix = text.substring(new_end);
+      if (suffix.startsWith(marker)) {
+        new_end += marker.length;
+        return;
+      }
+      const prefix = text.substring(0, new_start);
+      if (prefix.endsWith(marker)) {
+        new_start -= marker.length;
+        return;
+      }
+    }
+  };
+  for (let i = 0; i < 2; i++) {
+    expand_if_unbalanced("**");
+    expand_if_unbalanced("__");
+    expand_if_unbalanced("_");
+    expand_if_unbalanced("*");
+  }
+  return [new_start, new_end];
+}
+function _refine_match_boundaries(text, start, end) {
+  const markers = ["**", "__", "*", "_"];
+  let current_text = text.substring(start, end);
+  let best_start = start;
+  let best_end = end;
+  const countMarker = (str, mk) => (str.match(new RegExp(mk.replace(/\*/g, "\\*"), "g")) || []).length;
+  for (const marker of markers) {
+    if (current_text.startsWith(marker)) {
+      const current_score = countMarker(current_text, marker) % 2;
+      const trimmed_text = current_text.substring(marker.length);
+      const trimmed_score = countMarker(trimmed_text, marker) % 2;
+      if (current_score === 1 && trimmed_score === 0) {
+        best_start += marker.length;
+        current_text = trimmed_text;
+      }
+    }
+  }
+  for (const marker of markers) {
+    if (current_text.endsWith(marker)) {
+      const current_score = countMarker(current_text, marker) % 2;
+      const trimmed_text = current_text.substring(0, current_text.length - marker.length);
+      const trimmed_score = countMarker(trimmed_text, marker) % 2;
+      if (current_score === 1 && trimmed_score === 0) {
+        best_end -= marker.length;
+        current_text = trimmed_text;
+      }
+    }
+  }
+  return [best_start, best_end];
+}
+function _make_fuzzy_regex(target_text) {
+  target_text = _replace_smart_quotes(target_text);
+  const parts = [];
+  const token_pattern = /(_+)|(\s+)|(['"])|([.,;:\/])/g;
+  const md_noise = "[*_]*";
+  const structural_noise = "(?:\\s*(?:[*+\\->]|\\d+\\.)\\s+|\\s*\\n\\s*)";
+  const start_list_marker = "(?:[ \\t]*(?:[*+\\->]|\\d+\\.)\\s+)?";
+  parts.push(start_list_marker);
+  parts.push(md_noise);
+  let last_idx = 0;
+  let match;
+  const escapeRegExp = (str) => str.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+  while ((match = token_pattern.exec(target_text)) !== null) {
+    const literal = target_text.substring(last_idx, match.index);
+    if (literal) {
+      parts.push(escapeRegExp(literal));
+      parts.push(md_noise);
+    }
+    const g_underscore = match[1];
+    const g_space = match[2];
+    const g_quote = match[3];
+    const g_punct = match[4];
+    if (g_underscore) {
+      parts.push("_+");
+    } else if (g_space) {
+      if (g_space.includes("\n")) {
+        parts.push(`(?:${structural_noise}|\\s+)+`);
+      } else {
+        parts.push("\\s+");
+      }
+    } else if (g_quote) {
+      if (g_quote === "'") parts.push("[\u2018\u2019']");
+      else parts.push('["\u201C\u201D]');
+    } else if (g_punct) {
+      parts.push(escapeRegExp(g_punct));
+    }
+    parts.push(md_noise);
+    last_idx = token_pattern.lastIndex;
+  }
+  const remaining = target_text.substring(last_idx);
+  if (remaining) parts.push(escapeRegExp(remaining));
+  return parts.join("");
+}
+function _find_match_in_text(text, target) {
+  if (!target) return [-1, -1];
+  let idx = text.indexOf(target);
+  if (idx !== -1) return _find_safe_boundaries(text, idx, idx + target.length);
+  const norm_text = _replace_smart_quotes(text);
+  const norm_target = _replace_smart_quotes(target);
+  idx = norm_text.indexOf(norm_target);
+  if (idx !== -1) return _find_safe_boundaries(text, idx, idx + norm_target.length);
+  try {
+    const pattern = new RegExp(_make_fuzzy_regex(target));
+    const match = pattern.exec(text);
+    if (match) {
+      const raw_start = match.index;
+      const raw_end = match.index + match[0].length;
+      const [refined_start, refined_end] = _refine_match_boundaries(text, raw_start, raw_end);
+      return _find_safe_boundaries(text, refined_start, refined_end);
+    }
+  } catch (e) {
+  }
+  return [-1, -1];
+}
+function _build_critic_markup(target_text, new_text, comment, edit_index, include_index, highlight_only) {
+  const parts = [];
+  let [prefix_markup, clean_target, suffix_markup] = _strip_balanced_markers(target_text);
+  let clean_new = new_text;
+  if (prefix_markup && new_text) {
+    if (new_text.startsWith(prefix_markup) && new_text.endsWith(suffix_markup)) {
+      const inner_len = prefix_markup.length;
+      clean_new = new_text.length > inner_len * 2 ? new_text.substring(inner_len, new_text.length - inner_len) : new_text;
+    }
+  }
+  parts.push(prefix_markup);
+  if (highlight_only) {
+    parts.push(`{==${clean_target}==}`);
+  } else {
+    const has_target = Boolean(clean_target);
+    const has_new = Boolean(clean_new);
+    if (has_target && !has_new) parts.push(`{--${clean_target}--}`);
+    else if (!has_target && has_new) parts.push(`{++${clean_new}++}`);
+    else if (has_target && has_new) parts.push(`{--${clean_target}--}{++${clean_new}++}`);
+  }
+  parts.push(suffix_markup);
+  const meta_parts = [];
+  if (comment) meta_parts.push(comment);
+  if (include_index) meta_parts.push(`[Edit:${edit_index}]`);
+  if (meta_parts.length > 0) {
+    parts.push(`{>>${meta_parts.join(" ")}<<}`);
+  }
+  return parts.join("");
+}
+function apply_edits_to_markdown(markdown_text, edits, include_index = false, highlight_only = false) {
+  if (!edits || edits.length === 0) return markdown_text;
+  const matched_edits = [];
+  for (let idx = 0; idx < edits.length; idx++) {
+    const edit = edits[idx];
+    const target = edit.target_text || "";
+    if (!target) {
+      continue;
+    }
+    const [start, end] = _find_match_in_text(markdown_text, target);
+    if (start === -1) continue;
+    const actual_matched_text = markdown_text.substring(start, end);
+    matched_edits.push([start, end, actual_matched_text, edit, idx]);
+  }
+  const matched_edits_filtered = [];
+  const occupied_ranges = [];
+  matched_edits.sort((a, b) => a[4] - b[4]);
+  for (const [start, end, actual_text, edit, orig_idx] of matched_edits) {
+    let overlaps = false;
+    for (const [occ_start, occ_end] of occupied_ranges) {
+      if (start < occ_end && end > occ_start) {
+        overlaps = true;
+        break;
+      }
+    }
+    if (!overlaps) {
+      matched_edits_filtered.push([start, end, actual_text, edit, orig_idx]);
+      occupied_ranges.push([start, end]);
+    }
+  }
+  matched_edits_filtered.sort((a, b) => b[0] - a[0]);
+  let result = markdown_text;
+  for (const [start, end, actual_text, edit, orig_idx] of matched_edits_filtered) {
+    const new_txt = edit.new_text || "";
+    const [prefix_len, suffix_len] = trim_common_context(actual_text, new_txt);
+    const unmodified_prefix = prefix_len > 0 ? actual_text.substring(0, prefix_len) : "";
+    const unmodified_suffix = suffix_len > 0 ? actual_text.substring(actual_text.length - suffix_len) : "";
+    const t_end = actual_text.length - suffix_len;
+    const n_end = new_txt.length - suffix_len;
+    const isolated_target = actual_text.substring(prefix_len, t_end);
+    const isolated_new = new_txt.substring(prefix_len, n_end);
+    const markup = _build_critic_markup(
+      isolated_target,
+      isolated_new,
+      edit.comment,
+      orig_idx,
+      include_index,
+      highlight_only
+    );
+    const full_replacement = unmodified_prefix + markup + unmodified_suffix;
+    result = result.substring(0, start) + full_replacement + result.substring(end);
+  }
+  return result;
+}
+
+// src/pagination.ts
+var PAGE_TARGET_CHARS = 19e3;
+var APPENDIX_MARKER = "<!-- READONLY_BOUNDARY_START -->";
+var _CRITIC_TOKENS = {
+  "{++": "++}",
+  "{--": "--}",
+  "{==": "==}",
+  "{>>": "<<}"
+};
+var _CHG_ID_PATTERN = /\bChg:(\d+)\b/g;
+function split_structural_appendix(markdown) {
+  if (!markdown) return ["", ""];
+  const idx = markdown.indexOf(APPENDIX_MARKER);
+  if (idx === -1) return [markdown, ""];
+  const line_start = markdown.lastIndexOf("\n", idx) + 1;
+  const body = markdown.substring(0, line_start).trimEnd();
+  const appendix = markdown.substring(line_start);
+  return [body, appendix];
+}
+function paginate(markdown_body, structural_appendix = "") {
+  if (!markdown_body) {
+    const appendix_clean = structural_appendix ? structural_appendix.trim() : "";
+    const content = appendix_clean;
+    return {
+      pages: [{
+        page: 1,
+        total_pages: 1,
+        has_next: false,
+        has_prev: false,
+        tracked_change_count: _count_tracked_changes(content),
+        page_content: content
+      }],
+      total_pages: 1,
+      body_pages: [""],
+      body_page_offsets: [0]
+    };
+  }
+  const block_records = _tokenize_into_atomic_blocks(markdown_body);
+  const [body_pages, body_page_offsets] = _assemble_pages(block_records);
+  let final_pages;
+  if (structural_appendix && structural_appendix.trim()) {
+    const appendix = structural_appendix.trim();
+    final_pages = body_pages.map((bp) => bp ? `${bp}
+
+${appendix}` : appendix);
+  } else {
+    final_pages = [...body_pages];
+  }
+  const total = final_pages.length;
+  const page_infos = final_pages.map((content, i) => ({
+    page: i + 1,
+    total_pages: total,
+    has_next: i + 1 < total,
+    has_prev: i + 1 > 1,
+    tracked_change_count: _count_tracked_changes(content),
+    page_content: content
+  }));
+  return {
+    pages: page_infos,
+    total_pages: total,
+    body_pages,
+    body_page_offsets
+  };
+}
+function _tokenize_into_atomic_blocks(markdown_body) {
+  const raw_blocks = _split_on_safe_paragraph_breaks(markdown_body);
+  return _merge_footnote_sections(raw_blocks);
+}
+function _split_on_safe_paragraph_breaks(text) {
+  const counters = { "++}": 0, "--}": 0, "==}": 0, "<<}": 0 };
+  const blocks = [];
+  let block_start = 0;
+  let i = 0;
+  const n = text.length;
+  while (i < n) {
+    let matched_open = false;
+    for (const [open_tok, close_tok] of Object.entries(_CRITIC_TOKENS)) {
+      if (text.startsWith(open_tok, i)) {
+        counters[close_tok]++;
+        i += open_tok.length;
+        matched_open = true;
+        break;
+      }
+    }
+    if (matched_open) continue;
+    let matched_close = false;
+    for (const close_tok of Object.values(_CRITIC_TOKENS)) {
+      if (text.startsWith(close_tok, i)) {
+        if (counters[close_tok] > 0) counters[close_tok]--;
+        i += close_tok.length;
+        matched_close = true;
+        break;
+      }
+    }
+    if (matched_close) continue;
+    if (text[i] === "\n" && i + 1 < n && text[i + 1] === "\n") {
+      if (Object.values(counters).every((c) => c === 0)) {
+        const block_text = text.substring(block_start, i);
+        if (block_text) blocks.push([block_text, block_start]);
+        let j = i;
+        while (j < n && text[j] === "\n") j++;
+        i = j;
+        block_start = i;
+        continue;
+      }
+    }
+    i++;
+  }
+  if (block_start < n) {
+    const block_text = text.substring(block_start, n);
+    if (block_text) blocks.push([block_text, block_start]);
+  }
+  return blocks;
+}
+function _merge_footnote_sections(blocks) {
+  if (!blocks.length) return blocks;
+  const merged = [];
+  let i = 0;
+  while (i < blocks.length) {
+    const [block_text, block_offset] = blocks[i];
+    const stripped = block_text.trimStart();
+    const is_section_header = stripped.startsWith("## Footnotes") || stripped.startsWith("## Endnotes");
+    if (!is_section_header) {
+      merged.push([block_text, block_offset]);
+      i++;
+      continue;
+    }
+    let accumulated_text = block_text;
+    let j = i + 1;
+    while (j < blocks.length) {
+      const [next_text] = blocks[j];
+      const next_stripped = next_text.trimStart();
+      if (next_stripped.startsWith("[^fn-") || next_stripped.startsWith("[^en-")) {
+        accumulated_text = `${accumulated_text}
+
+${next_text}`;
+        j++;
+      } else {
+        break;
+      }
+    }
+    merged.push([accumulated_text, block_offset]);
+    i = j;
+  }
+  return merged;
+}
+function _assemble_pages(block_records) {
+  if (!block_records.length) return [[""], [0]];
+  const pages = [];
+  const page_starts = [];
+  let current_blocks = [];
+  let current_size = 0;
+  let current_start = -1;
+  const flush_current = () => {
+    if (current_blocks.length > 0) {
+      pages.push(current_blocks.join("\n\n"));
+      page_starts.push(current_start);
+    }
+    current_blocks = [];
+    current_size = 0;
+    current_start = -1;
+  };
+  for (const [block_text, block_offset] of block_records) {
+    const block_size = block_text.length;
+    const added_size = block_size + (current_blocks.length > 0 ? 2 : 0);
+    if (current_blocks.length > 0 && current_size + added_size > PAGE_TARGET_CHARS) {
+      flush_current();
+    }
+    if (current_blocks.length === 0 && block_size > PAGE_TARGET_CHARS) {
+      pages.push(block_text);
+      page_starts.push(block_offset);
+      continue;
+    }
+    if (current_blocks.length === 0) current_start = block_offset;
+    current_blocks.push(block_text);
+    current_size += current_size > 0 ? added_size : block_size;
+  }
+  flush_current();
+  if (!pages.length) return [[""], [0]];
+  return [pages, page_starts];
+}
+function _count_tracked_changes(page_content) {
+  const matches = [...page_content.matchAll(_CHG_ID_PATTERN)];
+  const distinct = new Set(matches.map((m) => m[1]));
+  return distinct.size;
+}
+
+// src/outline.ts
+var _HEADING_PREFIX_RE = /^(#{1,6}) /;
+var _HEURISTIC_MIN_WORDS = 3;
+function extract_outline(doc, projected_body, body_pages, body_page_offsets, paragraph_offsets = null) {
+  if (body_pages.length !== body_page_offsets.length) {
+    throw new Error("body_pages and body_page_offsets length mismatch");
+  }
+  const comments_map = extract_comments_data(doc.pkg);
+  const block_records = _walk_doc_body(doc, comments_map);
+  const heading_indices = [];
+  for (let idx = 0; idx < block_records.length; idx++) {
+    const rec = block_records[idx];
+    if (!(rec.is_paragraph && _is_heading(rec.item))) continue;
+    if (!_heading_passes_quality_filter(rec.item, comments_map)) continue;
+    heading_indices.push(idx);
+  }
+  if (heading_indices.length === 0) return [];
+  const nodes = [];
+  for (let h_pos = 0; h_pos < heading_indices.length; h_pos++) {
+    const rec_idx = heading_indices[h_pos];
+    const rec = block_records[rec_idx];
+    const paragraph = rec.item;
+    const level = _heading_level(paragraph);
+    const text = _heading_text(paragraph, comments_map);
+    const style = _determine_heading_style(paragraph);
+    const owned_end = _find_owned_end(block_records, heading_indices, h_pos, level);
+    const owned_blocks = block_records.slice(rec_idx + 1, owned_end);
+    const has_table = _direct_has_table(block_records, rec_idx + 1, owned_end);
+    const footnote_ids = _collect_footnote_ids(owned_blocks);
+    const page_num = _offset_to_page(rec.start_offset, body_page_offsets);
+    nodes.push({ level, text, page: page_num, style, has_table, footnote_ids });
+  }
+  return nodes;
+}
+function _direct_has_table(block_records, range_start, range_end) {
+  for (let idx = range_start; idx < range_end; idx++) {
+    const rec = block_records[idx];
+    if (rec.is_paragraph && _is_heading(rec.item)) return false;
+    if (rec.is_table) return true;
+  }
+  return false;
+}
+function _walk_doc_body(doc, comments_map) {
+  const parts = Array.from(iter_document_parts(doc));
+  let body_start_offset = 0;
+  let body_part = null;
+  for (const part of parts) {
+    if (part === doc) {
+      body_part = part;
+      break;
+    }
+    const part_text = _project_part(part, comments_map);
+    if (part_text) {
+      if (body_start_offset > 0) body_start_offset += 2;
+      body_start_offset += part_text.length;
+    }
+  }
+  if (!body_part) {
+    body_part = doc;
+    body_start_offset = 0;
+  } else {
+    if (body_start_offset > 0) body_start_offset += 2;
+  }
+  const records = [];
+  let cursor = body_start_offset;
+  let is_first_block = true;
+  for (const item of iter_block_items(body_part)) {
+    if (item instanceof Paragraph) {
+      const prefix = get_paragraph_prefix(item);
+      const p_text = build_paragraph_text(item, comments_map, false);
+      const block_len = (prefix + p_text).length;
+      if (!is_first_block) cursor += 2;
+      records.push({ item, is_paragraph: true, is_table: false, start_offset: cursor, projected_length: block_len });
+      cursor += block_len;
+      is_first_block = false;
+    } else if (item instanceof Table) {
+      const table_text = extract_table(item, comments_map, false, 0);
+      const block_len = table_text ? table_text.length : 0;
+      if (!is_first_block) cursor += 2;
+      const table_start = cursor;
+      records.push({ item, is_paragraph: false, is_table: true, start_offset: table_start, projected_length: block_len });
+      _record_table_inner_blocks_lite(item, table_start, records, comments_map);
+      cursor += block_len;
+      is_first_block = false;
+    }
+  }
+  return records;
+}
+function _compute_inner_block_offset(table, target_paragraph, table_start_offset, comments_map) {
+  const target_el = target_paragraph._element;
+  let cursor = table_start_offset;
+  let rows_processed = 0;
+  for (const row of table.rows) {
+    if (rows_processed > 0) cursor += 1;
+    const seen_cells = /* @__PURE__ */ new Set();
+    let cells_in_row = 0;
+    for (const cell of row.cells) {
+      if (seen_cells.has(cell)) continue;
+      seen_cells.add(cell);
+      if (cells_in_row > 0) cursor += 3;
+      const [new_cursor, found] = _walk_cell_for_offset(cell, target_el, cursor, comments_map);
+      if (found) return new_cursor;
+      cursor = new_cursor;
+      cells_in_row++;
+    }
+    rows_processed++;
+  }
+  return table_start_offset;
+}
+function _walk_cell_for_offset(cell, target_el, cell_start_cursor, comments_map) {
+  let cursor = cell_start_cursor;
+  let is_first_block = true;
+  for (const inner_item of iter_block_items(cell)) {
+    if (!is_first_block) cursor += 2;
+    if (inner_item instanceof Paragraph) {
+      if (inner_item._element === target_el) return [cursor, true];
+      const prefix = get_paragraph_prefix(inner_item);
+      const p_text = build_paragraph_text(inner_item, comments_map, false);
+      cursor += (prefix + p_text).length;
+    } else if (inner_item instanceof Table) {
+      const nested_offset = _compute_inner_block_offset(inner_item, new Paragraph(target_el, null), cursor, comments_map);
+      if (nested_offset !== cursor) {
+        if (_element_is_descendant(target_el, inner_item._element)) return [nested_offset, true];
+      }
+      const table_text = extract_table(inner_item, comments_map, false, 0);
+      cursor += table_text ? table_text.length : 0;
+    }
+    is_first_block = false;
+  }
+  return [cursor, false];
+}
+function _element_is_descendant(target_el, ancestor_el) {
+  let cur = target_el.parentNode;
+  while (cur) {
+    if (cur === ancestor_el) return true;
+    cur = cur.parentNode;
+  }
+  return false;
+}
+function _record_table_inner_blocks_lite(table, inherited_offset, records, comments_map) {
+  const seen_cells = /* @__PURE__ */ new Set();
+  for (const row of table.rows) {
+    for (const cell of row.cells) {
+      if (seen_cells.has(cell)) continue;
+      seen_cells.add(cell);
+      for (const inner_item of iter_block_items(cell)) {
+        if (inner_item instanceof Paragraph) {
+          const true_offset = _is_heading(inner_item) ? _compute_inner_block_offset(table, inner_item, inherited_offset, comments_map) : inherited_offset;
+          records.push({ item: inner_item, is_paragraph: true, is_table: false, start_offset: true_offset, projected_length: 0 });
+        } else if (inner_item instanceof Table) {
+          records.push({ item: inner_item, is_paragraph: false, is_table: true, start_offset: inherited_offset, projected_length: 0 });
+          _record_table_inner_blocks_lite(inner_item, inherited_offset, records, comments_map);
+        }
+      }
+    }
+  }
+}
+function _project_part(part, comments_map) {
+  const blocks = [];
+  const c_type = part.constructor.name;
+  if (c_type === "NotesPart") {
+    const header = part.note_type === "fn" ? "## Footnotes" : "## Endnotes";
+    blocks.push(`---
+${header}`);
+  }
+  let is_first_para = true;
+  for (const item of iter_block_items(part)) {
+    if (item.constructor.name === "FootnoteItem") {
+      const fn_text = _project_part(item, comments_map);
+      if (fn_text) blocks.push(fn_text);
+    } else if (item instanceof Paragraph) {
+      let prefix = get_paragraph_prefix(item);
+      if (is_first_para && c_type === "FootnoteItem") prefix = `[^${part.note_type}-${part.id}]: ${prefix}`;
+      const p_text = build_paragraph_text(item, comments_map, false);
+      blocks.push(prefix + p_text);
+      is_first_para = false;
+    } else if (item instanceof Table) {
+      const table_text = extract_table(item, comments_map, false, 0);
+      if (table_text) blocks.push(table_text);
+      is_first_para = false;
+    }
+  }
+  return blocks.join("\n\n");
+}
+function _is_heading(paragraph) {
+  return _HEADING_PREFIX_RE.test(get_paragraph_prefix(paragraph));
+}
+function _heading_passes_quality_filter(paragraph, comments_map) {
+  const style = _determine_heading_style(paragraph);
+  if (style !== "(heuristic)") return true;
+  const text = _heading_text(paragraph, comments_map);
+  if (!text) return false;
+  const word_count = (text.match(/\w+/g) || []).length;
+  return word_count >= _HEURISTIC_MIN_WORDS;
+}
+function _heading_level(paragraph) {
+  const match = _HEADING_PREFIX_RE.exec(get_paragraph_prefix(paragraph));
+  return match ? Math.min(match[1].length, 6) : 1;
+}
+function _heading_text(paragraph, comments_map) {
+  const p_text = build_paragraph_text(paragraph, comments_map, false);
+  let cleaned = _strip_critic_markup(p_text);
+  cleaned = _strip_inline_formatting(cleaned);
+  return cleaned.trim();
+}
+function _strip_critic_markup(text) {
+  if (!text) return "";
+  text = text.replace(/\{--[\s\S]*?--\}/g, "");
+  text = text.replace(/\{>>[\s\S]*?<<\}/g, "");
+  text = text.replace(/\{\+\+([\s\S]*?)\+\+\}/g, "$1");
+  text = text.replace(/\{==([\s\S]*?)==\}/g, "$1");
+  return text;
+}
+function _strip_inline_formatting(text) {
+  if (!text) return "";
+  text = text.replace(/\*\*(.+?)\*\*/g, "$1");
+  text = text.replace(/__(.+?)__/g, "$1");
+  text = text.replace(/(?<!\w)_(\S(?:.*?\S)?)_(?!\w)/g, "$1");
+  return text;
+}
+function _determine_heading_style(paragraph) {
+  const [style_cache, default_pstyle] = _get_style_cache(paragraph._parent.part || paragraph._parent);
+  const pPr = findChild(paragraph._element, "w:pPr");
+  let style_id = default_pstyle;
+  if (pPr) {
+    const oLvl = findChild(pPr, "w:outlineLvl");
+    if (oLvl && /^\d+$/.test(oLvl.getAttribute("w:val") || "")) {
+      const style = _safe_style_name(paragraph, style_cache, default_pstyle);
+      if (style && (style.startsWith("Heading") || style === "Title")) return style;
+      return "(outline_level)";
+    }
+    const pStyle = findChild(pPr, "w:pStyle");
+    if (pStyle) style_id = pStyle.getAttribute("w:val") || default_pstyle;
+  }
+  const style_name = style_id && style_cache && style_cache[style_id] ? style_cache[style_id].name : null;
+  if (style_name && (style_name.startsWith("Heading") || style_name === "Title")) return style_name;
+  if (style_name && /Heading[ ]?([1-6])(?![0-9])/.test(style_name)) return style_name;
+  return "(heuristic)";
+}
+function _safe_style_name(paragraph, style_cache, default_pstyle) {
+  const pPr = findChild(paragraph._element, "w:pPr");
+  let style_id = default_pstyle;
+  if (pPr) {
+    const pStyle = findChild(pPr, "w:pStyle");
+    if (pStyle) style_id = pStyle.getAttribute("w:val") || default_pstyle;
+  }
+  return style_id && style_cache && style_cache[style_id] ? style_cache[style_id].name : null;
+}
+function _find_owned_end(block_records, heading_indices, current_h_pos, current_level) {
+  for (let next_h_pos = current_h_pos + 1; next_h_pos < heading_indices.length; next_h_pos++) {
+    const next_idx = heading_indices[next_h_pos];
+    if (_heading_level(block_records[next_idx].item) <= current_level) return next_idx;
+  }
+  return block_records.length;
+}
+function _collect_footnote_ids(owned_blocks) {
+  const seen = /* @__PURE__ */ new Set();
+  const ordered = [];
+  for (const rec of owned_blocks) {
+    if (!rec.is_paragraph) continue;
+    for (const event of iter_paragraph_content(rec.item)) {
+      if (!("type" in event)) continue;
+      let fn_id = "";
+      if (event.type === "footnote") fn_id = `fn-${event.id}`;
+      else if (event.type === "endnote") fn_id = `en-${event.id}`;
+      else continue;
+      if (!seen.has(fn_id)) {
+        seen.add(fn_id);
+        ordered.push(fn_id);
+      }
+    }
+  }
+  return ordered;
+}
+function _offset_to_page(offset, body_page_offsets) {
+  if (!body_page_offsets || body_page_offsets.length === 0) return 1;
+  let page = 1;
+  for (let i = 0; i < body_page_offsets.length; i++) {
+    if (offset >= body_page_offsets[i]) page = i + 1;
+    else break;
+  }
+  return page;
+}
+
+// src/index.ts
+var identifyEngine = () => "adeu-core-node";
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  BatchValidationError,
+  DocumentMapper,
+  DocumentObject,
+  RedlineEngine,
+  apply_edits_to_markdown,
+  extractTextFromBuffer,
+  extract_outline,
+  generate_edits_from_text,
+  identifyEngine,
+  paginate,
+  split_structural_appendix,
+  trim_common_context
+});
+//# sourceMappingURL=index.cjs.map