@poe-platform/safe-bash 0.1.806 → 0.1.807

package/dist/safe-bash/command-chunks/chunk-2NE2GPSF.js

@@ -0,0 +1,546 @@
+import {
+  openDocumentLocations,
+  resolveDocxSelection
+} from "./chunk-LHDB4QO5.js";
+import {
+  validateDocxInvocation
+} from "./chunk-DE66JRWJ.js";
+import {
+  assertDocumentEditable,
+  publishDocumentArchive
+} from "./chunk-HPKUFWHW.js";
+import {
+  documentPartRole
+} from "./chunk-DXX2Z2QA.js";
+import {
+  DocumentPackage,
+  readDocumentArchive
+} from "./chunk-GLPIFP7N.js";
+import {
+  DocumentXmlEditor,
+  UnsupportedEditError,
+  activeXmlChildren,
+  assertFormattingHistoryEditable,
+  replaceSplitParagraphXml,
+  runElementOpen,
+  splitNativeTextRunXml,
+  xmlValue
+} from "./chunk-YPVBU7QF.js";
+import {
+  corePropertyKeys,
+  customPropertyType,
+  extendedPropertyKeys,
+  propertyDeclaration,
+  propertyGroupDefinition,
+  readPropertyNodes,
+  trimXmlWhitespace
+} from "./chunk-VEUQWV2V.js";
+import {
+  dialectForNamespace,
+  documentDialects
+} from "./chunk-MG7AJD5E.js";
+import {
+  compatibilityContainers
+} from "./chunk-GZ2N24A2.js";
+import {
+  closedRecord,
+  encodeGeneratedLocation
+} from "./chunk-LQOKYG3O.js";
+import {
+  isXmlContentType,
+  parseMediaType
+} from "./chunk-MWAAMNAM.js";
+import {
+  DocxUsageError
+} from "./chunk-2P7BLWWI.js";
+import {
+  archiveSettings
+} from "./chunk-IQFRPIXH.js";
+
+// packages/safe-bash-docx-engine/src/bookmark-references.ts
+function unsafe(message) {
+  throw new UnsupportedEditError(message);
+}
+function referenceOperand(instruction, name) {
+  let position = 0;
+  const tokens = [];
+  while (position < instruction.length) {
+    while (position < instruction.length && " 	\r\n".includes(instruction[position])) position++;
+    if (position === instruction.length) break;
+    const quoted = instruction[position] === '"';
+    if (quoted) position++;
+    const start = position;
+    while (position < instruction.length && (quoted ? instruction[position] !== '"' : !" 	\r\n".includes(instruction[position]))) position++;
+    const end = position;
+    if (quoted && position === instruction.length) unsafe("Cannot safely update a malformed field instruction.");
+    if (quoted) position++;
+    tokens.push({ value: instruction.slice(start, end), start, end });
+  }
+  const command = tokens[0]?.value.toUpperCase();
+  if ((command === "PAGE" || command === "NUMPAGES") && !instruction.slice(tokens[0].end).includes(name)) return void 0;
+  if (command !== "REF" && command !== "PAGEREF") {
+    if (instruction.includes(name)) unsafe("An unsupported field may reference the bookmark.");
+    return void 0;
+  }
+  const operand = tokens[1];
+  if (!operand || operand.value.startsWith("\\")) unsafe("A reference field is missing its bookmark operand.");
+  if (tokens.slice(2).some((token) => token.value === name)) unsafe("A field has an ambiguous bookmark dependency.");
+  return operand.value === name ? operand : void 0;
+}
+function updateBookmarkReferences(editors, oldName, newName, policy, budget, graph) {
+  const changes = [];
+  const dependency = () => {
+    if (policy === "reject") unsafe("The bookmark still has references; an explicit update or removal policy is required.");
+    if (newName === null !== (policy === "remove")) unsafe("The bookmark reference policy does not match the operation.");
+  };
+  for (const [part, editor] of editors) {
+    const type = parseMediaType(graph.getPart(part).content_type), root = editor.root;
+    const rootDialect = dialectForNamespace(root.namespace) ?? "transitional";
+    const math = documentDialects[rootDialect].m, role = documentPartRole(type, root);
+    const literalProperties = /* @__PURE__ */ new Set(), literalPropertyAttributes = /* @__PURE__ */ new Set(), literalPropertyContent = /* @__PURE__ */ new Set();
+    const mc = "http://schemas.openxmlformats.org/markup-compatibility/2006";
+    for (const group of ["core", "extended", "custom"]) {
+      const definition = propertyGroupDefinition(group, rootDialect);
+      if (type !== definition.contentType || root.namespace !== definition.namespace || root.localName !== definition.root) continue;
+      for (const property of readPropertyNodes(root, group, rootDialect, budget)) {
+        budget.charge("work", 1);
+        if (property.valueNode && property.value !== null && property.value.value !== null) {
+          budget.charge("retainedBytes", 8 + (property.valueContent?.length ?? 0) * 8);
+          literalProperties.add(property.valueNode);
+          for (const content of property.valueContent ?? []) literalPropertyContent.add(content);
+        }
+      }
+      const opaque = /* @__PURE__ */ new Set(), projected = [...editor.compatibility.content];
+      while (projected.length) {
+        const item = projected.pop();
+        budget.charge("work", 1);
+        if (!("source" in item)) continue;
+        budget.charge("retainedBytes", 16 + item.content.length * 8);
+        if (item.disposition !== "understood") opaque.add(item.source);
+        else projected.push(...item.content);
+      }
+      const declarations = group === "custom" ? [] : Object.keys(group === "core" ? corePropertyKeys : extendedPropertyKeys).map((key) => propertyDeclaration(group, key, rootDialect));
+      const pending = [{ node: root, scalar: false }];
+      while (pending.length) {
+        const { node, parent, scalar } = pending.pop();
+        budget.charge("work", 1 + node.attributes.length + declarations.length);
+        if (opaque.has(node)) continue;
+        const custom = group === "custom" && node.namespace === documentDialects[rootDialect].cus && node.localName === "property";
+        if (custom) {
+          for (const attribute2 of node.attributes) if (!attribute2.namespace && ["name", "pid", "fmtid"].includes(attribute2.localName)) {
+            budget.charge("retainedBytes", 8);
+            literalPropertyAttributes.add(attribute2);
+          }
+        }
+        const nativeScalar = group === "custom" ? node.namespace === documentDialects[rootDialect].vt && parent?.namespace === documentDialects[rootDialect].cus && parent.localName === "property" && customPropertyType(node.localName) !== null : declarations.some((entry) => entry.namespace === node.namespace && entry.localName === node.localName);
+        const literal = nativeScalar || scalar && node.namespace === mc && ["AlternateContent", "Choice", "Fallback"].includes(node.localName);
+        budget.charge("retainedBytes", 8 + node.children.length * 32);
+        if (literal) literalProperties.add(node);
+        for (const child of node.children) pending.push({ node: child, parent: node, scalar: literal });
+      }
+    }
+    const remove = /* @__PURE__ */ new Set();
+    let fields = [];
+    let deletedTail = "";
+    const attribute = (node, localName) => node.attributes.find((item) => item.namespace === node.namespace && item.localName === localName);
+    const traversal = [{ node: root, mathContext: "outside", position: -1 }];
+    while (traversal.length) {
+      const frame = traversal.at(-1);
+      if (frame.position >= 0) {
+        if (frame.position === frame.node.children.length) {
+          if (frame.outerFields) {
+            if (fields.length) unsafe("A complex field crosses a story boundary or is missing its end.");
+            fields = frame.outerFields;
+            deletedTail = frame.outerDeletedTail;
+          }
+          traversal.pop();
+        } else {
+          budget.charge("retainedBytes", 64);
+          traversal.push({ node: frame.node.children[frame.position++], parent: frame.node, mathContext: frame.mathContext, position: -1 });
+        }
+        continue;
+      }
+      const { node, parent } = frame;
+      let mathContext = frame.mathContext;
+      frame.position = 0;
+      budget.charge("work", 1);
+      const dialect = dialectForNamespace(node.namespace);
+      const word = dialect !== void 0 && node.namespace === documentDialects[dialect].w;
+      if (!word && node.namespace !== math && node.namespace !== "http://schemas.openxmlformats.org/markup-compatibility/2006") mathContext = "opaque";
+      if (mathContext === "outside" && (role === "story" || role === "glossary") && node.namespace === math && ["oMath", "oMathPara"].includes(node.localName)) mathContext = "unit";
+      const literalMathText = mathContext === "unit" && node.namespace === math && node.localName === "t" && parent?.namespace === math && parent.localName === "r" && node.children.length === 0;
+      const story = word && ["body", "hdr", "ftr", "footnote", "endnote", "comment", "txbxContent"].includes(node.localName);
+      frame.mathContext = mathContext;
+      if (story) {
+        frame.outerFields = fields;
+        frame.outerDeletedTail = deletedTail;
+        fields = [];
+        deletedTail = "";
+      }
+      for (const item of node.attributes) {
+        budget.charge("work", item.value.length);
+        if (item.namespace === "http://www.w3.org/2000/xmlns/") continue;
+        const knownWordAttribute = word && (item.namespace === node.namespace || item.namespace === documentDialects[dialect].r || item.namespace === "http://www.w3.org/XML/1998/namespace");
+        const knownMathFont = role === "settings" && parent?.namespace === math && parent.localName === "mathPr" && root.children.includes(parent) && node.namespace === math && node.localName === "mathFont" && item.namespace === math && item.localName === "val";
+        const compatibilityAttribute = item.namespace === mc || node.namespace === mc && node.localName === "Choice" && !item.namespace && item.localName === "Requires";
+        if (!knownWordAttribute && !knownMathFont && !compatibilityAttribute && !literalPropertyAttributes.has(item) && item.value.includes(oldName))
+          unsafe("An opaque XML attribute may reference the bookmark.");
+      }
+      if (!word && !literalMathText && !literalProperties.has(node)) {
+        const text = node.content.map((part2) => !literalPropertyContent.has(part2) && (part2.kind === "text" || part2.kind === "cdata") ? part2.text : "").join("");
+        budget.charge("work", text.length);
+        if (text.includes(oldName)) unsafe("Opaque XML text may reference the bookmark.");
+      }
+      if (word) {
+        const { r } = documentDialects[dialect];
+        if (node.localName === "hyperlink") {
+          const anchor = attribute(node, "anchor");
+          const external = node.attributes.some((item) => item.namespace === r && item.localName === "id");
+          if (!external && attribute(node, "docLocation")?.value.includes(oldName))
+            unsafe("An internal document-location reference cannot be safely updated.");
+          if (anchor?.value === oldName && !external) {
+            dependency();
+            if (policy === "remove") remove.add(node);
+            else changes.push(() => editor.setAttribute(node, anchor.name, newName));
+          }
+        } else if (node.localName === "fldSimple") {
+          const instruction = attribute(node, "instr");
+          if (!instruction) unsafe("A simple field is missing its instruction.");
+          budget.charge("work", instruction.value.length);
+          const operand = referenceOperand(instruction.value, oldName);
+          if (operand) {
+            dependency();
+            if (policy === "remove") remove.add(node);
+            else changes.push(() => editor.setAttribute(
+              node,
+              instruction.name,
+              instruction.value.slice(0, operand.start) + newName + instruction.value.slice(operand.end)
+            ));
+          }
+        } else if (node.localName === "fldChar") {
+          const type2 = attribute(node, "fldCharType")?.value;
+          if (type2 === "begin") {
+            if (fields.length) fields[fields.length - 1].nested = true;
+            fields.push({ nodes: [], separated: false, nested: false });
+          } else if (type2 === "separate") {
+            const field = fields[fields.length - 1];
+            if (!field || field.separated) unsafe("A complex field has an unmatched separator.");
+            field.separated = true;
+          } else if (type2 === "end") {
+            const field = fields.pop();
+            if (!field) unsafe("A complex field has an unmatched end.");
+            const instruction = field.nodes.map((part2) => part2.kind === "element" ? "" : part2.text).join("");
+            budget.charge("work", instruction.length);
+            const operand = referenceOperand(instruction, oldName);
+            if (operand) {
+              dependency();
+              if (field.nested) unsafe("Nested dependent fields cannot be safely updated.");
+              if (policy === "remove") unsafe("Complex bookmark reference removal is not supported safely.");
+              let offset = 0;
+              let inserted = false;
+              for (const part2 of field.nodes) {
+                if (part2.kind === "element") continue;
+                const start = Math.max(operand.start - offset, 0);
+                const end = Math.min(operand.end - offset, part2.text.length);
+                if (start < end) {
+                  const replacement = part2.text.slice(0, start) + (inserted ? "" : newName) + part2.text.slice(end);
+                  changes.push(() => editor.setText(part2, replacement));
+                  inserted = true;
+                }
+                offset += part2.text.length;
+              }
+            }
+          } else unsafe("A complex field has an unsupported delimiter.");
+        } else if (node.localName === "delInstrText") {
+          const instruction = node.content.map((part2) => part2.kind === "text" || part2.kind === "cdata" ? part2.text : "").join("");
+          budget.charge("work", instruction.length);
+          const candidate = deletedTail + instruction;
+          budget.charge("work", candidate.length);
+          if (candidate.includes(oldName)) unsafe("A deleted field instruction may reference the bookmark.");
+          deletedTail = candidate.slice(-Math.max(oldName.length - 1, 1));
+        } else if (node.localName === "instrText") {
+          const field = fields[fields.length - 1];
+          if (!field || field.separated || node.children.length) unsafe("Field instruction text has no safe instruction boundary.");
+          for (const part2 of node.content) {
+            if (part2.kind === "text" || part2.kind === "cdata") field.nodes.push(part2);
+          }
+        }
+      }
+    }
+    if (fields.length) unsafe("A complex field is missing its end.");
+    if (remove.size) {
+      const rebuild = [{ node: root, insideRemoval: false, position: 0, replacements: /* @__PURE__ */ new Map() }];
+      while (rebuild.length) {
+        const frame = rebuild.at(-1), { node, insideRemoval, replacements } = frame;
+        if (frame.position < node.children.length) {
+          budget.charge("retainedBytes", 64);
+          rebuild.push({ node: node.children[frame.position++], insideRemoval: insideRemoval || remove.has(node), position: 0, replacements: /* @__PURE__ */ new Map() });
+          continue;
+        }
+        budget.charge("work", 1);
+        const unwrap = remove.has(node);
+        if (unwrap && node.attributes.some((item) => item.namespace === "http://www.w3.org/2000/xmlns/" || item.namespace === "http://www.w3.org/XML/1998/namespace"))
+          unsafe("Reference removal cannot discard namespace bindings or inherited XML attributes.");
+        rebuild.pop();
+        if (!unwrap && !replacements.size) continue;
+        const xml = editor.sourceXml(node, replacements, unwrap);
+        budget.charge("retainedBytes", xml.length * 2);
+        if (insideRemoval) rebuild.at(-1).replacements.set(node, xml);
+        else changes.push(() => editor.replaceElement(node, xml));
+      }
+    }
+  }
+  for (const change of changes) change();
+}
+
+// packages/safe-bash-docx-engine/src/bookmarks.ts
+var attr = (node, name) => node.attributes.find((a) => a.namespace === node.namespace && a.localName === name)?.value;
+var identity = (part, path) => JSON.stringify([part, path]);
+function validName(name) {
+  const letter = (c) => c >= "A" && c <= "Z" || c >= "a" && c <= "z";
+  return name.length > 0 && name.length <= 40 && (letter(name[0]) || name[0] === "_") && [...name].every((c) => letter(c) || c >= "0" && c <= "9" || c === "_");
+}
+function inventory(editors, budget) {
+  const starts = [], ends = [], issues = [];
+  const report = (marker, issue) => {
+    marker.issues.push(issue);
+    issues.push(`${marker.part}: ${issue} (${marker.id})`);
+  };
+  for (const [part, editor] of editors) {
+    const containers = new Set(editor.compatibility[compatibilityContainers]);
+    let order = 0;
+    const fieldDepth = /* @__PURE__ */ new Map();
+    const path = [];
+    const frames = [{ node: editor.root, parent: editor.root, container: editor.root, unsafe: false, position: -1 }];
+    while (frames.length) {
+      const frame = frames.at(-1);
+      if (frame.position >= 0) {
+        if (frame.position === frame.node.children.length) {
+          frames.pop();
+          if (frames.length) path.pop();
+        } else {
+          const index = frame.position++;
+          budget.charge("retainedBytes", 64);
+          path.push(index);
+          frames.push({ node: frame.node.children[index], parent: containers.has(frame.node) ? frame.parent : frame.node, container: frame.container, unsafe: frame.unsafe, position: -1 });
+        }
+        continue;
+      }
+      const { node, parent } = frame;
+      frame.position = 0;
+      budget.charge("work", 1);
+      const word = dialectForNamespace(node.namespace) !== void 0;
+      if (word && ["body", "hdr", "ftr", "footnote", "endnote", "comment", "tc", "txbxContent"].includes(node.localName)) frame.container = node;
+      const container = frame.container;
+      if (word && node.localName === "fldChar") {
+        const depth = fieldDepth.get(container) ?? 0;
+        if (attr(node, "fldCharType") === "begin") fieldDepth.set(container, depth + 1);
+        else if (attr(node, "fldCharType") === "end") fieldDepth.set(container, Math.max(0, depth - 1));
+      }
+      frame.unsafe ||= word && ["ins", "del", "moveFrom", "moveTo", "sdt", "fldSimple", "hyperlink"].includes(node.localName);
+      if (word && ["bookmarkStart", "bookmarkEnd"].includes(node.localName)) {
+        const raw = attr(node, "id") ?? "";
+        const value = trimXmlWhitespace(raw), digits = value[0] === "+" || value[0] === "-" ? value.slice(1) : value;
+        const valid = digits.length > 0 && [...digits].every((c) => c >= "0" && c <= "9") && Number.isSafeInteger(Number(value)) && Number(value) >= 0;
+        budget.charge("retainedBytes", 128 + path.length * 8);
+        const marker = { part, path: [...path], node, parent, container, order: order++, id: valid ? String(Number(value)) : raw, name: attr(node, "name") ?? "", issues: [] };
+        (node.localName === "bookmarkStart" ? starts : ends).push(marker);
+        if (!valid) report(marker, "invalid-id");
+        if (frame.unsafe || (fieldDepth.get(container) ?? 0) > 0 || parent.namespace !== node.namespace || parent.localName !== "p" || node.children.length || node.content.some((c) => c.kind !== "text" || c.text.trim()) || attr(node, "colFirst") !== void 0 || attr(node, "colLast") !== void 0) report(marker, "illegal-boundary");
+        if (node.localName === "bookmarkStart" && !validName(marker.name)) report(marker, "invalid-name");
+      }
+    }
+  }
+  const startsById = /* @__PURE__ */ new Map(), endsById = /* @__PURE__ */ new Map(), names = /* @__PURE__ */ new Map();
+  for (const marker of starts) {
+    startsById.set(marker.id, [...startsById.get(marker.id) ?? [], marker]);
+    names.set(marker.name, [...names.get(marker.name) ?? [], marker]);
+  }
+  for (const marker of ends) endsById.set(marker.id, [...endsById.get(marker.id) ?? [], marker]);
+  for (const group of names.values()) if (group.length > 1) for (const marker of group) report(marker, "duplicate-name");
+  for (const id of /* @__PURE__ */ new Set([...startsById.keys(), ...endsById.keys()])) {
+    const left = startsById.get(id) ?? [], right = endsById.get(id) ?? [];
+    if (left.length > 1 || right.length > 1) for (const marker of [...left, ...right]) report(marker, "duplicate-id");
+    if (!left.length) for (const marker of right) report(marker, "missing-start");
+    if (!right.length) for (const marker of left) report(marker, "missing-end");
+    if (left.length !== 1 || right.length !== 1) continue;
+    const start = left[0], end = right[0];
+    start.end = end;
+    if (start.part !== end.part || start.container !== end.container) report(start, "illegal-boundary");
+    else if (end.order < start.order) report(start, "end-before-start");
+  }
+  for (const part of editors.keys()) {
+    const active = [];
+    for (const marker of [...starts, ...ends].filter((m) => m.part === part).sort((a, b) => a.order - b.order)) {
+      budget.charge("work", active.length + 1);
+      if (marker.node.localName === "bookmarkStart") {
+        if (marker.end) {
+          for (const previous of active) {
+            const issue = previous.end.order < marker.end.order ? "crossing" : "overlap";
+            report(previous, issue);
+            report(marker, issue);
+          }
+          active.push(marker);
+        }
+      } else {
+        const position = active.findIndex((m) => m.end === marker);
+        if (position >= 0) active.splice(position, 1);
+      }
+    }
+  }
+  return { starts, ends, issues };
+}
+function xmlEditors(archive, settings, budget) {
+  const graph = new DocumentPackage(archive, settings.limits, budget);
+  return { graph, editors: new Map(graph.parts.filter((p) => isXmlContentType(p.content_type)).map((p) => [p.partname, new DocumentXmlEditor(p.bytes, {}, void 0, budget)])) };
+}
+async function inspectDocumentBookmarks(input, options, context) {
+  const settings = archiveSettings(context);
+  const invocation = validateDocxInvocation({ operation: "bookmarks.list", inputs: ["document"], options }, settings.budget);
+  const budget = settings.budget.lower(Object.fromEntries((options.limit ?? []).map((item) => [item.name, item.value])));
+  const archive = await readDocumentArchive(input, { ...settings, budget });
+  const found = inventory(xmlEditors(archive, settings, budget).editors, budget);
+  if (found.issues.length) {
+    const data2 = { items: [], issues: found.issues };
+    budget.check("serializedOutput", new TextEncoder().encode(JSON.stringify({ version: 1, operation: "bookmarks.list", ok: true, data: data2, affected: 0, locations: [], warnings: [], errors: [] }) + "\n").length);
+    return data2;
+  }
+  const document = await openDocumentLocations(input, { ...settings, budget });
+  const selected = resolveDocxSelection(document, invocation);
+  budget.check("matches", selected.length);
+  const markers = new Map(found.starts.map((m) => [identity(m.part, m.path), m]));
+  const items = selected.map((location) => {
+    const marker = markers.get(identity(location.value.part, location.value.path));
+    if (!marker) throw new UnsupportedEditError("Bookmark start cannot be resolved.");
+    return { location, name: marker.name, id: marker.id, end: marker.end ? { part: marker.end.part, path: marker.end.path } : null, issues: marker.issues };
+  });
+  const data = { items, issues: found.issues };
+  budget.check("serializedOutput", new TextEncoder().encode(JSON.stringify({ version: 1, operation: "bookmarks.list", ok: true, data, affected: 0, locations: selected, warnings: [], errors: [] }) + "\n").length);
+  return data;
+}
+function insertRange(editor, p, from, to, id, name, budget) {
+  if (p.localName !== "p" || from >= to) throw new UnsupportedEditError("Bookmark creation requires a nonempty paragraph text range.");
+  const markers = /* @__PURE__ */ new Set(["bookmarkStart", "bookmarkEnd", "commentRangeStart", "commentRangeEnd", "proofErr", "permStart", "permEnd"]);
+  const patches = /* @__PURE__ */ new Map();
+  let offset = 0, began = false, ended = false;
+  const start = `<bm:bookmarkStart xmlns:bm="${p.namespace}" bm:id="${id}" bm:name="${xmlValue(name)}"/>`;
+  const end = `<bm:bookmarkEnd xmlns:bm="${p.namespace}" bm:id="${id}"/>`;
+  const children = activeXmlChildren(editor, budget);
+  for (const child of children(p)) {
+    budget.charge("work", 1);
+    if (child.namespace === p.namespace && (child.localName === "pPr" || markers.has(child.localName))) continue;
+    if (child.namespace !== p.namespace || child.localName !== "r") throw new UnsupportedEditError("Bookmark creation requires simple runs without fields, links or controlled content.");
+    const active = children(child), props = active.filter((leaf) => leaf.namespace === p.namespace && leaf.localName === "rPr"), leaves = active.filter((leaf) => !props.includes(leaf));
+    if (props.length > 1 || leaves.some((leaf) => leaf.namespace !== p.namespace || !["t", "tab", "ptab", "br", "cr", "noBreakHyphen", "softHyphen", "lastRenderedPageBreak", "footnoteRef", "endnoteRef", "annotationRef"].includes(leaf.localName) || leaf.content.some((item) => item.kind !== "text"))) throw new UnsupportedEditError("Bookmark creation requires supported scalar run content.");
+    const count = leaves.reduce((sum, leaf) => sum + (["lastRenderedPageBreak", "footnoteRef", "endnoteRef", "annotationRef"].includes(leaf.localName) ? 0 : leaf.localName === "t" ? [...leaf.text].length : 1), 0);
+    const left = Math.max(0, Math.min(count, from - offset));
+    const right = Math.max(0, Math.min(count, to - offset));
+    const startHere = !began && from >= offset && from < offset + count;
+    const endHere = !ended && to > offset && to <= offset + count;
+    if (startHere || endHere) {
+      assertFormattingHistoryEditable(editor.root, child, children, budget);
+      let content;
+      if ((!startHere || left === 0) && (!endHere || right === count)) content = (startHere ? start : "") + editor.sourceXml(child) + (endHere ? end : "");
+      else {
+        const fragments = [/* @__PURE__ */ new Map(), /* @__PURE__ */ new Map(), /* @__PURE__ */ new Map()];
+        let scalarOffset = 0;
+        for (const leaf of leaves) {
+          budget.charge("work", 1);
+          if (["lastRenderedPageBreak", "footnoteRef", "endnoteRef", "annotationRef"].includes(leaf.localName)) {
+            fragments[scalarOffset < left ? 0 : scalarOffset < right ? 1 : 2].set(leaf, editor.sourceXml(leaf));
+            continue;
+          }
+          const scalars = leaf.localName === "t" ? [...leaf.text] : [" "], next = scalarOffset + scalars.length;
+          const ranges = [[scalarOffset, Math.min(next, left)], [Math.max(scalarOffset, left), Math.min(next, right)], [Math.max(scalarOffset, right), next]];
+          ranges.forEach(([from2, to2], side) => {
+            if (from2 >= to2) return;
+            const markup = to2 - from2 === scalars.length ? editor.sourceXml(leaf) : runElementOpen({ ...leaf, attributes: leaf.attributes.filter((attribute) => !(attribute.namespace === "http://www.w3.org/XML/1998/namespace" && attribute.localName === "space")) }).slice(0, -1) + ` xml:space="preserve">${xmlValue(scalars.slice(from2 - scalarOffset, to2 - scalarOffset).join(""))}</${leaf.name}>`;
+            fragments[side].set(leaf, markup);
+          });
+          scalarOffset = next;
+        }
+        const sides = [0, 1, 2].filter((side) => fragments[side].size), rendered = editor[splitNativeTextRunXml](child, sides.map((side) => ({ properties: props[0] ? editor.sourceXml(props[0]) : "", content: fragments[side] })), false), output = ["", "", ""];
+        sides.forEach((side, index) => output[side] = rendered[index]);
+        content = output[0] + (startHere ? start : "") + output[1] + (endHere ? end : "") + output[2];
+      }
+      patches.set(child, content);
+      began ||= startHere;
+      ended ||= endHere;
+    }
+    offset += count;
+  }
+  if (!began || !ended) throw new UnsupportedEditError("Bookmark range exceeds admitted paragraph text.");
+  editor[replaceSplitParagraphXml](p, runElementOpen(p) + editor.sourceXml(p, patches, true) + `</${p.name}>`);
+}
+async function editDocumentBookmarks(input, request, context) {
+  closedRecord(request, ["operation", "options", "input"]);
+  if (!["bookmarks.add", "bookmarks.set", "bookmarks.remove"].includes(request.operation)) throw new DocxUsageError("Expected a bookmark editing operation.");
+  const settings = archiveSettings(context);
+  const invocation = validateDocxInvocation({ operation: request.operation, inputs: [request.input?.path ?? "document"], options: request.options }, settings.budget);
+  const options = invocation.options;
+  const budget = settings.budget.lower(Object.fromEntries((options.limit ?? []).map((item) => [item.name, item.value])));
+  const document = await openDocumentLocations(input, { ...settings, budget });
+  const selected = resolveDocxSelection(document, invocation);
+  budget.check("matches", selected.length);
+  let archive = document.snapshot();
+  assertDocumentEditable(archive, { ...settings, budget });
+  const { editors, graph } = xmlEditors(archive, settings, budget);
+  const found = inventory(editors, budget);
+  if (found.issues.length) throw new UnsupportedEditError("Bookmark structure is unsafe: " + found.issues.join("; "));
+  const before = selected[0];
+  if (selected.length !== 1) throw new UnsupportedEditError("Bookmark edits require exactly one selection.");
+  const editor = editors.get(before.value.part);
+  let node = editor.root;
+  const ancestors = [node];
+  for (const index of before.value.path) {
+    node = node.children[index];
+    ancestors.push(node);
+  }
+  if (ancestors.some((n) => dialectForNamespace(n.namespace) && ["ins", "del", "moveFrom", "moveTo", "sdt", "fldSimple", "hyperlink"].includes(n.localName))) throw new UnsupportedEditError("Bookmark edits cannot cross tracked or controlled content.");
+  const adding = request.operation === "bookmarks.add", removing = request.operation === "bookmarks.remove";
+  const marker = found.starts.find((m) => identity(m.part, m.path) === identity(before.value.part, before.value.path));
+  if (!adding && !marker) throw new UnsupportedEditError("Bookmark selection cannot be resolved.");
+  if (!removing && (!validName(options.name) || found.starts.some((m) => m !== marker && m.name === options.name))) throw new UnsupportedEditError("Bookmark names must be legal and unique across the document.");
+  let changed = true;
+  if (adding) {
+    const range = before.value.range;
+    if (!range) throw new UnsupportedEditError("Bookmark creation requires a selected text range.");
+    const used = new Set(found.starts.map((m) => m.id));
+    let id = 0;
+    while (used.has(String(id))) {
+      budget.charge("work", 1);
+      id++;
+    }
+    insertRange(editor, node, range.start, range.end, String(id), options.name, budget);
+  } else if (!removing && marker.name === options.name) changed = false;
+  else {
+    updateBookmarkReferences(editors, marker.name, removing ? null : options.name, options.references, budget, graph);
+    if (removing) {
+      editor.replaceElement(marker.node, "");
+      editors.get(marker.end.part).replaceElement(marker.end.node, "");
+    } else editor.setAttribute(marker.node, { namespace: marker.node.namespace, localName: "name" }, options.name);
+  }
+  archive = { ...archive, members: archive.members.map((member) => {
+    const xml = editors.get("/" + member.name);
+    return xml ? { ...member, bytes: xml.serialize() } : member;
+  }) };
+  const finalEditors = xmlEditors(archive, settings, budget).editors, finalInventory = inventory(finalEditors, budget);
+  if (finalInventory.issues.length) throw new UnsupportedEditError("Bookmark mutation would create overlapping or invalid ranges.");
+  let after = before;
+  if (changed) {
+    const path = removing ? before.value.path.slice(0, -1) : finalInventory.starts.find((m) => m.name === options.name).path;
+    const value = { ...before.value, generation: before.value.generation + 1, path, range: null };
+    after = { kind: removing ? "paragraph" : "bookmark", value, token: encodeGeneratedLocation(value), positions: before.positions };
+  }
+  const changes = changed ? [{ kind: adding ? "insert" : removing ? "remove" : "rename", before, after }] : [];
+  const publication = { ...request.input ? { input: request.input } : {}, ...options.output === void 0 ? {} : { output: options.output }, ...options.inPlace === void 0 ? {} : { inPlace: options.inPlace }, ...options.force === void 0 ? {} : { force: options.force }, ...options.dryRun === void 0 ? {} : { dryRun: options.dryRun }, ...options.json === void 0 ? {} : { json: options.json } };
+  const prospective = { changed, changes, dryRun: options.dryRun ?? false, output: options.dryRun ? null : { path: options.inPlace ? request.input?.path ?? null : options.output === "-" ? null : options.output ?? null, bytes: Math.min(settings.limits.maxArchiveBytes, Number.MAX_SAFE_INTEGER), sha256: "0".repeat(64) } };
+  budget.check("serializedOutput", new TextEncoder().encode(JSON.stringify({ version: 1, operation: request.operation, ok: true, data: prospective, affected: changes.length, locations: changes.map((c) => c.after), warnings: [], errors: [] }) + "\n").length);
+  const result = await publishDocumentArchive(archive, publication, { ...context, budget });
+  return { changed, changes, dryRun: options.dryRun ?? false, output: result.published.length ? { path: result.published[0].path, bytes: result.published[0].bytes, sha256: result.archiveSha256 } : null };
+}
+
+export {
+  inspectDocumentBookmarks,
+  editDocumentBookmarks
+};