@arbidocs/coedit 0.4.111 → 0.4.113

package/dist/commands.js

@@ -1,5 +1,6 @@
-import { ACCEPTED_PARAGRAPH_PROPERTIES, openHeadlessDocument } from '@docx-editor.dev/core/store';
+import { ACCEPTED_PARAGRAPH_PROPERTIES, openHeadlessDocument, readXml } from '@docx-editor.dev/core/store';
 import { resolveNumberingLevel, resolveStoryListItems, buildStyleCascadeTable, withNumberingStyleLinks, buildNumberingIndex } from '@docx-editor.dev/core/layout';
+import { zipSync, strToU8, strFromU8, unzipSync } from 'fflate';
 
 // src/commands/index.ts
 
@@ -263,6 +264,35 @@ function documentNumbering(source) {
     }
   };
 }
+var W_NAMESPACES = 'xmlns:w="http://schemas.openxmlformats.org/wordprocessingml/2006/main" xmlns:r="http://schemas.openxmlformats.org/officeDocument/2006/relationships"';
+var INVALID_XML = /[\u0000-\u0008\u000B\u000C\u000E-\u001F￾￿]/g;
+var esc = (text) => text.replace(INVALID_XML, "").replace(/&/g, "&amp;").replace(/</g, "&lt;").replace(/>/g, "&gt;").replace(/"/g, "&quot;");
+var documentXml = (body) => `<?xml version="1.0" encoding="UTF-8" standalone="yes"?>
+<w:document ${W_NAMESPACES}><w:body>${body}</w:body></w:document>`;
+var stylesXml = (defaults, styles) => `<?xml version="1.0" encoding="UTF-8" standalone="yes"?>
+<w:styles xmlns:w="http://schemas.openxmlformats.org/wordprocessingml/2006/main">${defaults}${styles}</w:styles>`;
+var CONTENT_TYPES = `<?xml version="1.0" encoding="UTF-8" standalone="yes"?>
+<Types xmlns="http://schemas.openxmlformats.org/package/2006/content-types"><Default Extension="rels" ContentType="application/vnd.openxmlformats-package.relationships+xml"/><Default Extension="xml" ContentType="application/xml"/><Override PartName="/word/document.xml" ContentType="application/vnd.openxmlformats-officedocument.wordprocessingml.document.main+xml"/><Override PartName="/word/styles.xml" ContentType="application/vnd.openxmlformats-officedocument.wordprocessingml.styles+xml"/><Override PartName="/docProps/core.xml" ContentType="application/vnd.openxmlformats-package.core-properties+xml"/></Types>`;
+var ROOT_RELS = `<?xml version="1.0" encoding="UTF-8" standalone="yes"?>
+<Relationships xmlns="http://schemas.openxmlformats.org/package/2006/relationships"><Relationship Id="rId1" Type="http://schemas.openxmlformats.org/officeDocument/2006/relationships/officeDocument" Target="word/document.xml"/><Relationship Id="rId2" Type="http://schemas.openxmlformats.org/package/2006/relationships/metadata/core-properties" Target="docProps/core.xml"/></Relationships>`;
+var documentRels = (more = "") => `<?xml version="1.0" encoding="UTF-8" standalone="yes"?>
+<Relationships xmlns="http://schemas.openxmlformats.org/package/2006/relationships"><Relationship Id="rId1" Type="http://schemas.openxmlformats.org/officeDocument/2006/relationships/styles" Target="styles.xml"/>${more}</Relationships>`;
+var hyperlinkRelationship = (id, url) => `<Relationship Id="${esc(id)}" Type="http://schemas.openxmlformats.org/officeDocument/2006/relationships/hyperlink" Target="${esc(url)}" TargetMode="External"/>`;
+var coreXml = (title, at) => `<?xml version="1.0" encoding="UTF-8" standalone="yes"?>
+<cp:coreProperties xmlns:cp="http://schemas.openxmlformats.org/package/2006/metadata/core-properties" xmlns:dc="http://purl.org/dc/elements/1.1/" xmlns:dcterms="http://purl.org/dc/terms/" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"><dc:title>${esc(
+  title
+)}</dc:title><dcterms:created xsi:type="dcterms:W3CDTF">${at}</dcterms:created><dcterms:modified xsi:type="dcterms:W3CDTF">${at}</dcterms:modified></cp:coreProperties>`;
+function docxPackage(parts) {
+  const at = new Date(parts.at ?? Date.now()).toISOString().replace(/\.\d{3}Z$/, "Z");
+  return zipSync({
+    "[Content_Types].xml": strToU8(CONTENT_TYPES),
+    "_rels/.rels": strToU8(ROOT_RELS),
+    "docProps/core.xml": strToU8(coreXml(parts.title, at)),
+    "word/document.xml": strToU8(parts.document),
+    "word/styles.xml": strToU8(parts.styles),
+    "word/_rels/document.xml.rels": strToU8(documentRels(parts.relationships))
+  });
+}
 
 // src/commands/references.ts
 var REF_BOOKMARK_PREFIX = "_Ref";
@@ -312,6 +342,126 @@ function brokenCrossReferences(port) {
     (p) => (p.marks ?? []).filter((m) => m.styleId === BROKEN_CROSS_REFERENCE_STYLE).map((m) => ({ paragraphId: p.id, offset: m.offset, text: m.text }))
   );
 }
+function newRefBookmark(taken, random = Math.random) {
+  for (; ; ) {
+    const name = `${REF_BOOKMARK_PREFIX}${String(Math.floor(random() * 9e8) + 1e8)}`;
+    if (!taken.has(name)) return name;
+  }
+}
+var styled = (style) => style ? `<w:rPr><w:rStyle w:val="${style}"/></w:rPr>` : "";
+var run = (text, style) => `<w:r>${styled(style)}<w:t xml:space="preserve">${esc(text)}</w:t></w:r>`;
+function refFieldXml(instruction, cached) {
+  const r = (inner) => `<w:r>${styled(CROSS_REFERENCE_STYLE)}${inner}</w:r>`;
+  return `${r('<w:fldChar w:fldCharType="begin"/>')}${r(
+    `<w:instrText xml:space="preserve"> ${esc(instruction)} </w:instrText>`
+  )}${r('<w:fldChar w:fldCharType="separate"/>')}${run(cached, CROSS_REFERENCE_STYLE)}${r(
+    '<w:fldChar w:fldCharType="end"/>'
+  )}`;
+}
+var refTooltip = (value, mode) => mode === "number" ? `Cross-reference to clause ${value}` : `Cross-reference to \u201C${value}\u201D`;
+function crossReferenceXml(bookmark, mode, value) {
+  return `<w:hyperlink w:anchor="${esc(bookmark)}" w:tooltip="${esc(
+    refTooltip(value, mode)
+  )}" w:history="1">${refFieldXml(refInstruction(bookmark, mode), value)}</w:hyperlink>`;
+}
+var refInstruction = (bookmark, mode) => mode === "number" ? `REF ${bookmark} \\r \\h` : `REF ${bookmark} \\h`;
+var refResult = (target, mode) => mode === "number" && target.number ? target.number : target.text;
+var allBookmarks = (port) => new Set(port.paragraphs().flatMap((p) => p.bookmarks));
+function ensureTargetBookmark(port, target, mode) {
+  const paragraph = port.paragraphs().find((p) => p.id === target.paragraphId);
+  if (!paragraph) throw new Error("That clause is no longer in the document.");
+  const existing = paragraph.bookmarks.find((b) => b.startsWith(REF_BOOKMARK_PREFIX));
+  if (existing && mode === "number") return existing;
+  const name = newRefBookmark(allBookmarks(port));
+  const start = `<w:bookmarkStart w:id="0" w:name="${name}"/>`;
+  const end = '<w:bookmarkEnd w:id="0"/>';
+  if (mode === "number") {
+    port.setCaret({ paragraphId: paragraph.id, offset: 0 });
+    if (!port.paste(`<w:p>${start}${end}</w:p>`, "", false))
+      throw new Error("The cross-reference target could not be marked.");
+    return name;
+  }
+  const runs = port.runsXml(paragraph.id);
+  if (!runs) throw new Error("This heading cannot be referred to by its text; use its number.");
+  port.deleteRange(
+    { paragraphId: paragraph.id, offset: 0 },
+    { paragraphId: paragraph.id, offset: paragraph.text.length }
+  );
+  if (!port.paste(`<w:p>${start}${runs}${end}</w:p>`, paragraph.text, false))
+    throw new Error("The cross-reference target could not be marked.");
+  return name;
+}
+function pastePoint(port, caret) {
+  const paragraph = port.paragraphs().find((p) => p.id === caret.paragraphId);
+  if (paragraph?.text[caret.offset - 1] !== FIELD_ATOM) return caret;
+  port.setCaret(caret);
+  port.typeText(" ");
+  return { paragraphId: caret.paragraphId, offset: caret.offset + 1 };
+}
+function markCrossReferenceTarget(port, target, mode) {
+  if (mode === "number" && !target.number) mode = "text";
+  const bookmark = ensureTargetBookmark(port, target, mode);
+  return { bookmark, mode, value: refResult(target, mode) };
+}
+function insertCrossReferenceField(port, { bookmark, mode, value }, caret) {
+  caret = pastePoint(port, caret);
+  port.setCaret(caret);
+  if (!port.paste(`<w:p>${crossReferenceXml(bookmark, mode, value)}</w:p>`, value, false))
+    throw new Error("The cross-reference could not be inserted.");
+  port.setCaret({ paragraphId: caret.paragraphId, offset: caret.offset + 1 });
+  return { bookmark };
+}
+function insertCrossReference(port, target, mode, caret) {
+  return insertCrossReferenceField(port, markCrossReferenceTarget(port, target, mode), caret);
+}
+var documentReferenceTooltip = (text, appName = "ARBI") => `Cross-reference: ${text} \u2014 opens in ${appName}`;
+function insertDocumentReference(port, reference, caret) {
+  const text = reference.text.trim();
+  if (!text) throw new Error("Enter the reference text.");
+  const tooltip = documentReferenceTooltip(text, reference.appName).slice(0, 255);
+  caret = pastePoint(port, caret);
+  port.setCaret(caret);
+  const link = `<w:p><w:hyperlink r:id="rIdRef1"${tooltip ? ` w:tooltip="${esc(tooltip)}"` : ""} w:history="1">${run(text, CROSS_REFERENCE_STYLE)}</w:hyperlink></w:p>`;
+  if (!port.paste(link, text, false, hyperlinkRelationship("rIdRef1", reference.url)))
+    throw new Error("The reference could not be inserted.");
+  port.setCaret({ paragraphId: caret.paragraphId, offset: caret.offset + text.length });
+}
+function refreshCrossReferences(port) {
+  const stale = staleCrossReferences(port).sort(
+    (a, b) => a.paragraphId === b.paragraphId ? b.offset - a.offset : 0
+  );
+  let refreshed = 0;
+  for (const ref of stale) {
+    const paragraph = port.paragraphs().find((p) => p.id === ref.paragraphId);
+    if (!paragraph || paragraph.text[ref.offset - 1] === FIELD_ATOM) continue;
+    const at = { paragraphId: ref.paragraphId, offset: ref.offset };
+    port.deleteRange(at, { paragraphId: ref.paragraphId, offset: ref.offset + 1 });
+    port.setCaret(at);
+    const text = ref.value ?? (ref.cached.trim() || ref.bookmark);
+    const body = ref.value === null ? run(text, BROKEN_CROSS_REFERENCE_STYLE) : crossReferenceXml(ref.bookmark, ref.mode, ref.value);
+    if (port.paste(`<w:p>${body}</w:p>`, text, false) && ref.value !== null) refreshed++;
+  }
+  return { refreshed, broken: brokenCrossReferences(port) };
+}
+var RUN_PARTS = /* @__PURE__ */ new Set(["rPr", "t", "tab", "br", "lastRenderedPageBreak"]);
+var SKIPPED = /* @__PURE__ */ new Set(["pPr", "bookmarkStart", "bookmarkEnd", "proofErr", "permStart", "permEnd"]);
+function serialize(node) {
+  if (node.kind === "textValue") return esc(node.value ?? "");
+  const name = `${node.prefix ?? "w"}:${node.localName}`;
+  const attrs = (node.attributes ?? []).map((a) => ` ${a.prefix ? `${a.prefix}:` : ""}${a.localName}="${esc(a.value)}"`).join("");
+  const children = (node.children ?? []).map((c) => serialize(c)).join("");
+  return children ? `<${name}${attrs}>${children}</${name}>` : `<${name}${attrs}/>`;
+}
+function paragraphRunsXml(paragraph) {
+  const runs = [];
+  for (const child2 of paragraph.children ?? []) {
+    if (child2.localName && SKIPPED.has(child2.localName)) continue;
+    if (child2.localName !== "r") return null;
+    if ((child2.children ?? []).some((c) => !c.localName || !RUN_PARTS.has(c.localName))) return null;
+    runs.push(serialize(child2));
+  }
+  return runs.length ? runs.join("") : null;
+}
 var AGENT_UNDO_MAP = "agentUndo";
 var attr2 = (node, name) => node.attributes?.find((a) => a.localName === name)?.value;
 var child = (node, name) => node?.children?.find((c) => c.localName === name);
@@ -475,17 +625,511 @@ function undoOps(root, record) {
   return ops;
 }
 
+// src/commands/terms.ts
+var QUOTES = `"\u201C\u201D\u201E\u201F'\u2018\u2019\u201A\u201B\xAB\xBB`;
+var OPEN_CLOSE = {
+  '"': '"',
+  "\u201C": "\u201D",
+  "\u201E": "\u201C",
+  "\u201F": "\u201D",
+  "'": "'",
+  "\u2018": "\u2019",
+  "\u201A": "\u2018",
+  "\u201B": "\u2019",
+  "\xAB": "\xBB"
+};
+var EMPHASIS = /^(\*\*|__|\*|_)/;
+var CONNECTORS = /^(?:shall\s+(?:have\s+the\s+meaning|mean|include)s?|ha(?:s|ve)\s+the\s+meanings?|means?\s+and\s+includes?|means|mean|includes|include|[:—–]|\s-\s|-\s)/i;
+var MAX_TERM_LENGTH = 80;
+var MAX_TERM_WORDS = 10;
+function plain(text) {
+  return text.replace(/\\([\\`*_{}[\]()#+\-.!"'])/g, "$1").replace(/(\*\*|__)(.+?)\1/g, "$2").replace(/\s+/g, " ").trim();
+}
+function termKey(term) {
+  return plain(term).replace(new RegExp(`[${QUOTES}*_]`, "g"), "").replace(/\s+/g, " ").trim().toLowerCase();
+}
+var validTerm = (term) => term.length > 0 && term.length <= MAX_TERM_LENGTH && term.split(/\s+/).length <= MAX_TERM_WORDS && /\p{L}/u.test(term);
+function connectorAt(rest) {
+  const lead = rest.length - rest.trimStart().length;
+  const spaced = /^\s-\s/.exec(rest);
+  if (spaced) return spaced[0].length;
+  const match = CONNECTORS.exec(rest.slice(lead));
+  return match ? lead + match[0].length : 0;
+}
+function parseDefinition(text) {
+  let s = plain(text);
+  for (let i = 0; i < 3; i++) s = s.replace(EMPHASIS, "").trimStart();
+  let term;
+  let rest;
+  const open = s[0];
+  const close = open ? OPEN_CLOSE[open] : void 0;
+  if (close) {
+    const end = s.indexOf(close, 1);
+    if (end < 0) return null;
+    term = s.slice(1, end);
+    rest = s.slice(end + 1);
+    rest = rest.replace(new RegExp(`^(?:\\*\\*|__|\\*|_|[${QUOTES}])+`), "");
+  } else {
+    const match = /^(.+?)(\s+(?:shall\s+(?:have\s+the\s+meaning|mean|include)s?|ha(?:s|ve)\s+the\s+meanings?|means?\s+and\s+includes?|means|includes)\b|\s*[:—–]|\s+-\s)/i.exec(
+      s
+    );
+    if (!match) return null;
+    term = match[1];
+    rest = s.slice(match[1].length);
+  }
+  term = term.replace(/(\*\*|__|\*|_)/g, "").trim();
+  const joint = connectorAt(rest);
+  if (!joint || !validTerm(term)) return null;
+  const meaning = rest.slice(joint).trim();
+  if (!meaning) return null;
+  return { term, rest: rest.replace(/^\s+/, " ").replace(/^ (?=[:—–])/, ""), meaning };
+}
+var compareTerms = (a, b) => a.localeCompare(b, void 0, { sensitivity: "base", numeric: true });
+var DEFINITION_BOOKMARK_PREFIX = "_dt_";
+var MAX_BOOKMARK_LENGTH = 40;
+function definitionBookmark(factId) {
+  return (DEFINITION_BOOKMARK_PREFIX + factId.replace(/[^A-Za-z0-9_]/g, "_")).slice(
+    0,
+    MAX_BOOKMARK_LENGTH
+  );
+}
+function definitionIdOfBookmark(name) {
+  const match = /^_dt_([a-z]{3})_([A-Za-z0-9]+)$/.exec(name);
+  return match ? `${match[1]}-${match[2]}` : null;
+}
+var W_NS = "http://schemas.openxmlformats.org/wordprocessingml/2006/main";
+var TemplateError = class extends Error {
+  constructor(message) {
+    super(message);
+    this.name = "TemplateError";
+  }
+};
+function parse(xml, part = "part") {
+  const read = readXml(xml, { maxBytes: 64 * 1024 * 1024, maxElements: 2e6 });
+  if (!read.ok) throw new TemplateError(`${part} is not readable XML (${read.reason})`);
+  const convert = (node) => node.type === "text" ? node.value : { name: node.name, attrs: { ...node.attributes }, children: node.children.map(convert) };
+  const root = read.nodes.map(convert).find((n) => typeof n !== "string");
+  if (!root) throw new TemplateError(`${part} has no root element`);
+  const w = root.attrs["xmlns:w"];
+  if (w !== void 0 && w !== W_NS) throw new TemplateError(`${part} binds w: to ${w}`);
+  return root;
+}
+var escText = (s) => s.replace(/&/g, "&amp;").replace(/</g, "&lt;").replace(/>/g, "&gt;");
+var escAttr = (s) => escText(s).replace(/"/g, "&quot;");
+function serialize2(root) {
+  const out = ['<?xml version="1.0" encoding="UTF-8" standalone="yes"?>\n'];
+  const walk = (node) => {
+    if (typeof node === "string") return void out.push(escText(node));
+    out.push("<", node.name);
+    for (const [k, v] of Object.entries(node.attrs)) out.push(" ", k, '="', escAttr(v), '"');
+    if (node.children.length === 0) return void out.push("/>");
+    out.push(">");
+    node.children.forEach(walk);
+    out.push("</", node.name, ">");
+  };
+  walk(root);
+  return out.join("");
+}
+var el = (name, attrs = {}, children = []) => ({
+  name,
+  attrs,
+  children
+});
+var isEl = (n) => typeof n === "object" && n !== null;
+var kids = (e, name) => e.children.filter((c) => isEl(c) && (name === void 0 || c.name === name));
+var kid = (e, name) => e ? kids(e, name)[0] : void 0;
+
+// src/template/pkg.ts
+var REL = "http://schemas.openxmlformats.org/officeDocument/2006/relationships";
+var RT = {
+  officeDocument: `${REL}/officeDocument`};
+var Pkg = class _Pkg {
+  files;
+  types;
+  constructor(files) {
+    this.files = files;
+    const ct = this.find("[Content_Types].xml");
+    if (!ct) throw new TemplateError("not a Word package: no [Content_Types].xml");
+    this.types = parse(strFromU8(files.get(ct)), "[Content_Types].xml");
+  }
+  static read(bytes) {
+    let files;
+    try {
+      files = unzipSync(bytes);
+    } catch {
+      throw new TemplateError("not a Word package: not a zip");
+    }
+    return new _Pkg(new Map(Object.entries(files).filter(([n]) => !n.endsWith("/"))));
+  }
+  write() {
+    this.files.set(
+      this.find("[Content_Types].xml") ?? "[Content_Types].xml",
+      strToU8(serialize2(this.types))
+    );
+    return zipSync(Object.fromEntries(this.files), { level: 6 });
+  }
+  /** The stored name of a part, matched case-insensitively as OPC does. */
+  find(name) {
+    const key = name.replace(/^\//, "").toLowerCase();
+    for (const n of this.files.keys()) if (n.toLowerCase() === key) return n;
+    return void 0;
+  }
+  has(name) {
+    return this.find(name) !== void 0;
+  }
+  text(name) {
+    const n = this.find(name);
+    return n === void 0 ? void 0 : strFromU8(this.files.get(n));
+  }
+  xml(name) {
+    const t = this.text(name);
+    return t === void 0 ? void 0 : parse(t, name);
+  }
+  setXml(name, root, contentType) {
+    this.files.set(this.find(name) ?? name, strToU8(serialize2(root)));
+    if (contentType) this.setContentType(name, contentType);
+  }
+  setBytes(name, bytes, contentType) {
+    this.files.set(this.find(name) ?? name, bytes);
+    if (contentType) this.setContentType(name, contentType);
+  }
+  remove(name) {
+    const n = this.find(name);
+    if (n === void 0) return;
+    this.files.delete(n);
+    this.types.children = this.types.children.filter(
+      (c) => !(typeof c !== "string" && c.name === "Override" && c.attrs.PartName.toLowerCase() === `/${n.toLowerCase()}`)
+    );
+    this.files.delete(relsName(n));
+  }
+  contentType(name) {
+    const part = `/${name.replace(/^\//, "")}`.toLowerCase();
+    const override = kids(this.types, "Override").find(
+      (o) => o.attrs.PartName.toLowerCase() === part
+    );
+    if (override) return override.attrs.ContentType;
+    const ext = part.slice(part.lastIndexOf(".") + 1);
+    return kids(this.types, "Default").find((d) => d.attrs.Extension.toLowerCase() === ext)?.attrs.ContentType;
+  }
+  setContentType(name, type) {
+    const part = `/${name.replace(/^\//, "")}`;
+    const override = kids(this.types, "Override").find(
+      (o) => o.attrs.PartName.toLowerCase() === part.toLowerCase()
+    );
+    if (override) override.attrs.ContentType = type;
+    else this.types.children.push(el("Override", { PartName: part, ContentType: type }));
+  }
+  /** A `Default` for an extension (media), unless one exists. */
+  ensureDefault(ext, type) {
+    if (!kids(this.types, "Default").some(
+      (d) => d.attrs.Extension.toLowerCase() === ext.toLowerCase()
+    ))
+      this.types.children.unshift(el("Default", { Extension: ext, ContentType: type }));
+  }
+  rels(owner) {
+    const root = this.xml(relsName(owner));
+    if (!root) return [];
+    return kids(root, "Relationship").map((r) => ({
+      id: r.attrs.Id,
+      type: r.attrs.Type,
+      target: r.attrs.Target,
+      external: r.attrs.TargetMode === "External"
+    }));
+  }
+  setRels(owner, rels) {
+    const root = el(
+      "Relationships",
+      { xmlns: "http://schemas.openxmlformats.org/package/2006/relationships" },
+      rels.map(
+        (r) => el("Relationship", {
+          Id: r.id,
+          Type: r.type,
+          Target: r.target,
+          ...r.external ? { TargetMode: "External" } : {}
+        })
+      )
+    );
+    this.setXml(relsName(owner), root);
+  }
+  /** Add a relationship from `owner`; returns its new id. */
+  addRel(owner, type, target, external = false) {
+    const rels = this.rels(owner);
+    const id = freshId(new Set(rels.map((r) => r.id)), "rIdT");
+    rels.push({ id, type, target, external });
+    this.setRels(owner, rels);
+    return id;
+  }
+  /** The part a relationship of `owner` points at (internal targets only). */
+  target(owner, rel) {
+    return resolveTarget(owner, rel.target);
+  }
+  /** The first internal part of a relationship type from `owner`. */
+  partOf(owner, type) {
+    const rel = this.rels(owner).find((r) => r.type === type && !r.external);
+    return rel && this.find(this.target(owner, rel));
+  }
+  /** The main document part (`word/document.xml` by convention). */
+  get main() {
+    const main = this.partOf("", RT.officeDocument);
+    if (!main) throw new TemplateError("not a Word package: no main document part");
+    return main;
+  }
+};
+function relsName(owner) {
+  const slash = owner.lastIndexOf("/");
+  return `${owner.slice(0, slash + 1)}_rels/${owner.slice(slash + 1)}.rels`;
+}
+function resolveTarget(owner, target) {
+  if (target.startsWith("/")) return target.slice(1);
+  const base = owner.slice(0, owner.lastIndexOf("/") + 1).split("/").filter(Boolean);
+  for (const seg of target.split("/")) {
+    if (seg === "..") base.pop();
+    else if (seg !== "." && seg !== "") base.push(seg);
+  }
+  return base.join("/");
+}
+function freshId(taken, prefix) {
+  for (let i = 1; ; i++) if (!taken.has(`${prefix}${i}`)) return `${prefix}${i}`;
+}
+
+// src/template/track.ts
+var TRACKED = /* @__PURE__ */ new Set(["w:ins", "w:del", "w:moveFrom", "w:moveTo"]);
+function trackInsertion(fragment, revision, covered) {
+  const pkg = Pkg.read(fragment);
+  const main = pkg.main;
+  const root = pkg.xml(main);
+  const body = kid(root, "w:body");
+  if (!root || !body) return fragment;
+  const attrs = { "w:id": "1", "w:author": revision.author, "w:date": revision.date };
+  const lastParagraph = body.children.filter(isEl).findLast((c) => c.name === "w:p");
+  const visit = (node) => {
+    node.children = node.children.map((child2) => {
+      if (!isEl(child2)) return child2;
+      if (child2.name === "w:r") return TRACKED.has(node.name) ? child2 : el("w:ins", attrs, [child2]);
+      if (TRACKED.has(child2.name)) return child2;
+      if (child2.name === "w:tr") {
+        markRow(child2, attrs);
+        return child2;
+      }
+      visit(child2);
+      if (child2.name === "w:p" && (covered || child2 !== lastParagraph)) markParagraph(child2, attrs);
+      return child2;
+    });
+  };
+  visit(body);
+  pkg.setXml(main, root);
+  return pkg.write();
+}
+function markParagraph(p, attrs) {
+  let pPr = kid(p, "w:pPr");
+  if (!pPr) p.children.unshift(pPr = el("w:pPr"));
+  let rPr = kid(pPr, "w:rPr");
+  if (!rPr) {
+    rPr = el("w:rPr");
+    const at = pPr.children.findIndex(
+      (c) => isEl(c) && (c.name === "w:sectPr" || c.name === "w:pPrChange")
+    );
+    pPr.children.splice(at < 0 ? pPr.children.length : at, 0, rPr);
+  }
+  if (!kid(rPr, "w:ins")) rPr.children.unshift(el("w:ins", attrs));
+}
+function markRow(tr, attrs) {
+  let trPr = kid(tr, "w:trPr");
+  if (!trPr) {
+    trPr = el("w:trPr");
+    const after = tr.children.findIndex((c) => isEl(c) && c.name === "w:tblPrEx");
+    tr.children.splice(after + 1, 0, trPr);
+  }
+  if (kid(trPr, "w:ins")) return;
+  const at = trPr.children.findIndex((c) => isEl(c) && c.name === "w:trPrChange");
+  trPr.children.splice(at < 0 ? trPr.children.length : at, 0, el("w:ins", attrs));
+}
+
+// src/commands/fragment.ts
+var CHARACTER_STYLES = {
+  [DEFINED_TERM_STYLE]: `<w:style w:type="character" w:customStyle="1" w:styleId="${DEFINED_TERM_STYLE}"><w:name w:val="Defined Term"/><w:rPr><w:u w:val="dotted" w:color="7F7F7F"/></w:rPr></w:style>`,
+  [CROSS_REFERENCE_STYLE]: `<w:style w:type="character" w:customStyle="1" w:styleId="${CROSS_REFERENCE_STYLE}"><w:name w:val="Cross Reference"/><w:rPr><w:color w:val="1F4E79"/><w:u w:val="dotted" w:color="8EA9C1"/></w:rPr></w:style>`,
+  [BROKEN_CROSS_REFERENCE_STYLE]: `<w:style w:type="character" w:customStyle="1" w:styleId="${BROKEN_CROSS_REFERENCE_STYLE}"><w:name w:val="Cross Reference Broken"/><w:basedOn w:val="${CROSS_REFERENCE_STYLE}"/><w:rPr><w:color w:val="C00000"/><w:u w:val="wave" w:color="C00000"/></w:rPr></w:style>`
+};
+function stylesUsed(body) {
+  return [...new Set([...body.matchAll(/<w:rStyle w:val="([^"]+)"/g)].map((m) => m[1]))];
+}
+var fragmentStyles = (ids) => stylesXml(
+  "",
+  `<w:style w:type="paragraph" w:default="1" w:styleId="Normal"><w:name w:val="Normal"/><w:qFormat/></w:style>${ids.map((id) => CHARACTER_STYLES[id] ?? "").join("")}`
+);
+var textRun = (text, props = "") => `<w:r>${props ? `<w:rPr>${props}</w:rPr>` : ""}<w:t xml:space="preserve">${esc(text)}</w:t></w:r>`;
+function definitionTooltip(definition) {
+  const line = `\u201C${definition.term}\u201D${definition.rest}`.replace(/\s+/g, " ").trim();
+  return line.length > 255 ? `${line.slice(0, 254)}\u2026` : line;
+}
+var definitionParagraphText = (definition) => `\u201C${definition.term}\u201D${definition.rest}`;
+function definitionParagraphXml(definition, bookmark, id = 0) {
+  return `<w:p><w:bookmarkStart w:id="${id}" w:name="${esc(bookmark)}"/>${textRun("\u201C")}${textRun(
+    definition.term,
+    "<w:b/>"
+  )}${textRun("\u201D")}<w:bookmarkEnd w:id="${id}"/>${textRun(definition.rest)}</w:p>`;
+}
+function headingParagraphXml(text, styleId) {
+  return styleId ? `<w:p><w:pPr><w:pStyle w:val="${esc(styleId)}"/></w:pPr>${textRun(text)}</w:p>` : `<w:p><w:pPr><w:keepNext/></w:pPr>${textRun(text, "<w:b/>")}</w:p>`;
+}
+function termLinkXml(term, bookmark, tooltip) {
+  return `<w:p><w:hyperlink w:anchor="${esc(bookmark)}" w:tooltip="${esc(tooltip)}" w:history="1">${textRun(
+    term,
+    `<w:rStyle w:val="${DEFINED_TERM_STYLE}"/>`
+  )}</w:hyperlink></w:p>`;
+}
+function fragmentPackage(body, covered, {
+  revision,
+  relationships,
+  styles = stylesUsed(body)
+} = {}) {
+  const untracked = docxPackage({
+    document: documentXml(body),
+    styles: fragmentStyles(styles),
+    title: "Defined terms",
+    relationships
+  });
+  return revision ? trackInsertion(untracked, revision, covered) : untracked;
+}
+var attr3 = (node, name) => node.attributes?.find((a) => a.localName === name)?.value;
+function documentStyleIds(root) {
+  const ids = /* @__PURE__ */ new Set();
+  for (const style of root?.children ?? [])
+    if (style.localName === "style") {
+      const id = attr3(style, "styleId");
+      if (id) ids.add(id);
+    }
+  return ids;
+}
+
+// src/commands/definitions.ts
+var DEFINITIONS_HEADING = "Definitions";
+var SECTION_TITLE = /^(definitions?(\s*(and|&)\s*interpretations?)?|interpretations?(\s*(and|&)\s*definitions?)?|defined\s+terms|glossary)$/i;
+var NUMBERING = /^(?:(?:clause|section|article|schedule|part)\s+)?(?:[0-9]+(?:\.[0-9]+)*|[A-Z]|[ivxlc]+)[.):]?\s+(?:[-–—]\s*)?/i;
+function isDefinitionsTitle(paragraph) {
+  if (!paragraph.topLevel) return false;
+  const title = paragraph.text.trim().replace(NUMBERING, "").replace(/[.:]+$/, "").trim();
+  return SECTION_TITLE.test(title) && (paragraph.heading || title.length <= 40);
+}
+function findDefinitionsSection(paragraphs) {
+  const title = paragraphs.findIndex(isDefinitionsTitle);
+  if (title < 0) return null;
+  let end = title + 1;
+  while (end < paragraphs.length && paragraphs[end].topLevel && !paragraphs[end].heading) end++;
+  return { title, start: title + 1, end };
+}
+var termOf = (paragraph) => parseDefinition(paragraph.text)?.term ?? null;
+function insertionIndex(paragraphs, section, term, skip = /* @__PURE__ */ new Set()) {
+  let afterLast = section.start;
+  for (let i = section.start; i < section.end; i++) {
+    if (skip.has(paragraphs[i].id)) continue;
+    const other = termOf(paragraphs[i]);
+    if (other === null) continue;
+    if (compareTerms(other, term) > 0) return i;
+    afterLast = i + 1;
+  }
+  return afterLast;
+}
+var headingStyle = (paragraphs) => paragraphs.find((p) => p.topLevel && p.heading && p.styleId)?.styleId;
+function insertParagraphs(port, index, body, count, keep) {
+  const before = port.paragraphs();
+  const kept = keep ? before.findIndex((p) => p.id === keep.paragraphId) : -1;
+  if (index < before.length) {
+    port.setCaret({ paragraphId: before[index].id, offset: 0 });
+  } else {
+    const last = before[before.length - 1];
+    port.setCaret({ paragraphId: last.id, offset: last.text.length });
+    port.splitParagraph();
+    const opened = port.paragraphs();
+    port.setCaret({ paragraphId: opened[opened.length - 1].id, offset: 0 });
+  }
+  if (!port.paste(body, "", true)) throw new Error("The definition could not be added.");
+  if (!keep || kept < 0) return keep;
+  const after = port.paragraphs();
+  const moved = index <= kept ? kept + count : kept;
+  return { paragraphId: after[moved]?.id ?? keep.paragraphId, offset: keep.offset };
+}
+function addDefinition(port, definition, keep) {
+  const paragraphs = port.paragraphs();
+  const section = findDefinitionsSection(paragraphs);
+  const paragraph = definitionParagraphXml(definition, definitionBookmark(definition.id));
+  if (section)
+    return insertParagraphs(
+      port,
+      insertionIndex(paragraphs, section, definition.term),
+      paragraph,
+      1,
+      keep
+    );
+  return insertParagraphs(
+    port,
+    paragraphs.length,
+    headingParagraphXml(DEFINITIONS_HEADING, headingStyle(paragraphs)) + paragraph,
+    2,
+    keep
+  );
+}
+var hasBookmark = (paragraphs, name) => paragraphs.some((p) => p.bookmarks.includes(name));
+function insertDefinedTerm(port, definition, options = {}) {
+  const start = port.caret();
+  if (!start) throw new Error("Place the cursor where the term should go.");
+  let caret = start;
+  if (options.replace) {
+    caret = { paragraphId: start.paragraphId, offset: Math.max(0, start.offset - options.replace) };
+    port.deleteRange(caret, start);
+  }
+  const bookmark = definitionBookmark(definition.id);
+  const addedDefinition = !hasBookmark(port.paragraphs(), bookmark);
+  if (addedDefinition) caret = addDefinition(port, definition, caret) ?? caret;
+  port.setCaret(caret);
+  if (!port.paste(
+    termLinkXml(definition.term, bookmark, definitionTooltip(definition)),
+    definition.term,
+    false
+  ))
+    throw new Error("The term could not be inserted.");
+  port.setCaret({ paragraphId: caret.paragraphId, offset: caret.offset + definition.term.length });
+  return { addedDefinition };
+}
+function definitionsById(definitions) {
+  return new Map(definitions.map((d) => [d.id, d]));
+}
+function definitionOfAnchor(anchor, definitions) {
+  const id = definitionIdOfBookmark(anchor.replace(/^#/, ""));
+  return id ? definitions.get(id) : void 0;
+}
+
 // src/commands/index.ts
 function documentReader(view) {
   const root = () => view.part().root;
   let paragraphs;
   let items;
   let names;
+  let notes;
+  const readNotes = () => {
+    const out = /* @__PURE__ */ new Map();
+    for (const part of view.currentPackage?.().parts.values() ?? []) {
+      const root2 = part.root;
+      const kind = root2?.localName === "footnotes" ? "footnote" : root2?.localName === "endnotes" ? "endnote" : null;
+      if (!kind) continue;
+      for (const note of root2?.children ?? []) {
+        const id = note.attributes?.find((a) => a.localName === "id")?.value;
+        if (id)
+          out.set(
+            `${kind}:${id}`,
+            readParagraphs(note).map((p) => p.text).join(" ")
+          );
+      }
+    }
+    return out;
+  };
   const numbering = documentNumbering({ ...view, root });
   return {
     paragraphs: () => paragraphs ??= readParagraphs(root()),
     listItems: () => items ??= numbering.listItems(),
     levelOf: numbering.levelOf,
+    noteText: (kind, id) => (notes ??= readNotes()).get(`${kind}:${id}`),
     styleName: (id) => (names ??= styleNames(view.stylesRoot())).get(id) ?? id
   };
 }
@@ -495,6 +1139,6 @@ function readDocument(bytes) {
   return documentReader(opened.view);
 }
 
-export { AGENT_UNDO_MAP, BROKEN_CROSS_REFERENCE_STYLE, CROSS_REFERENCE_STYLE, DEFINED_TERM_STYLE, FIELD_ATOM, REF_BOOKMARK_PREFIX, WATCHED_STYLES, brokenCrossReferences, crossReferences, documentNumbering, documentReader, fieldNodeIds, filterTargets, listTargets, paragraphIndex, paragraphNumber, paragraphState, readDocument, readParagraphs, sectionStates, staleCrossReferences, styleNames, tableOf, tableState, undoOps };
+export { AGENT_UNDO_MAP, BROKEN_CROSS_REFERENCE_STYLE, CHARACTER_STYLES, CROSS_REFERENCE_STYLE, DEFINED_TERM_STYLE, DEFINITIONS_HEADING, DEFINITION_BOOKMARK_PREFIX, FIELD_ATOM, REF_BOOKMARK_PREFIX, WATCHED_STYLES, W_NAMESPACES, addDefinition, brokenCrossReferences, compareTerms, crossReferenceXml, crossReferences, definitionBookmark, definitionIdOfBookmark, definitionOfAnchor, definitionParagraphText, definitionParagraphXml, definitionTooltip, definitionsById, documentNumbering, documentReader, documentReferenceTooltip, documentStyleIds, documentXml, docxPackage, ensureTargetBookmark, esc, fieldNodeIds, filterTargets, findDefinitionsSection, fragmentPackage, headingParagraphXml, hyperlinkRelationship, insertCrossReference, insertCrossReferenceField, insertDefinedTerm, insertDocumentReference, insertionIndex, isDefinitionsTitle, listTargets, markCrossReferenceTarget, newRefBookmark, paragraphIndex, paragraphNumber, paragraphRunsXml, paragraphState, parseDefinition, readDocument, readParagraphs, refFieldXml, refInstruction, refResult, refTooltip, refreshCrossReferences, sectionStates, staleCrossReferences, styleNames, stylesUsed, stylesXml, tableOf, tableState, termKey, termLinkXml, undoOps };
 //# sourceMappingURL=commands.js.map
 //# sourceMappingURL=commands.js.map