@poe-platform/safe-bash 0.1.806 → 0.1.807

package/dist/safe-bash/command-chunks/chunk-W543LSYH.js

@@ -0,0 +1,899 @@
+import {
+  openDocumentLocations,
+  resolveDocxSelection
+} from "./chunk-LHDB4QO5.js";
+import {
+  validateDocxInvocation
+} from "./chunk-DE66JRWJ.js";
+import {
+  paragraphTextRun
+} from "./chunk-GGOZXIGH.js";
+import {
+  findRelationshipPart
+} from "./chunk-4LXDJES2.js";
+import {
+  LocationIndex,
+  addressKey
+} from "./chunk-IR6ZKAUH.js";
+import {
+  assertDocumentEditable,
+  publishDocumentArchive
+} from "./chunk-HPKUFWHW.js";
+import {
+  DocumentPackage
+} from "./chunk-GLPIFP7N.js";
+import {
+  DocumentXmlEditor,
+  UnsupportedEditError,
+  activeXmlChildren,
+  assertFormattingHistoryEditable,
+  insertParagraphAfter,
+  mergeStyleChildren,
+  paragraphProperties,
+  paragraphUnits,
+  replaceListPropertyXml,
+  runElementOpen,
+  selectNamedStyles,
+  sourceRootEnvelope,
+  xmlValue
+} from "./chunk-YPVBU7QF.js";
+import {
+  storedBoolean,
+  trimXmlWhitespace
+} from "./chunk-VEUQWV2V.js";
+import {
+  dialectForNamespace,
+  documentDialects
+} from "./chunk-MG7AJD5E.js";
+import {
+  plainLength
+} from "./chunk-R4TYL2G6.js";
+import {
+  MarkupCompatibility,
+  compatibilityContainers
+} from "./chunk-GZ2N24A2.js";
+import {
+  closedRecord,
+  encodeGeneratedLocation
+} from "./chunk-LQOKYG3O.js";
+import {
+  relativePartTarget
+} from "./chunk-WAKYUXVQ.js";
+import {
+  parseDocumentXml
+} from "./chunk-MWAAMNAM.js";
+import {
+  DocxUsageError
+} from "./chunk-2P7BLWWI.js";
+import {
+  InvalidValueError,
+  archiveSettings
+} from "./chunk-IQFRPIXH.js";
+
+// packages/safe-bash-docx-engine/src/numbering.ts
+var numberingFormats = ["bullet", "decimal", "lowerLetter", "upperLetter", "lowerRoman", "upperRoman"];
+function numberingAttribute(node, name = "val") {
+  return node?.attributes.find((a) => a.namespace === node.namespace && a.localName === name)?.value;
+}
+function numberingChild(node, name) {
+  const children = node?.children.filter((c) => c.namespace === node.namespace && c.localName === name) ?? [];
+  if (children.length > 1) throw new UnsupportedEditError("Duplicate numbering properties are ambiguous.");
+  return children[0];
+}
+function nonnegativeInteger(value) {
+  if (value === void 0) return void 0;
+  value = trimXmlWhitespace(value);
+  if (!value) return void 0;
+  const digits = value[0] === "+" || value[0] === "-" ? value.slice(1) : value;
+  const number = Number(value);
+  return digits && [...digits].every((c) => c >= "0" && c <= "9") && Number.isSafeInteger(number) && number >= 0 ? number : void 0;
+}
+function integer(value, maximum = Number.MAX_SAFE_INTEGER) {
+  const number = nonnegativeInteger(value);
+  if (number === void 0 || number > maximum)
+    throw new UnsupportedEditError("Numbering requires bounded nonnegative integer identifiers and levels.");
+  return number;
+}
+var NumberingGraph = class {
+  constructor(xml, styles, budget) {
+    this.xml = xml;
+    this.styles = styles;
+    this.budget = budget;
+    if (xml.root.localName !== "numbering") throw new UnsupportedEditError("Expected a numbering root.");
+    this.project(xml.root);
+    if (styles) this.project(styles);
+    for (const node of this.children(xml.root)) {
+      budget.charge("work", 1);
+      if (node.namespace !== xml.root.namespace) continue;
+      if (node.localName === "abstractNum" || node.localName === "num") {
+        const abstract = node.localName === "abstractNum";
+        const id = integer(numberingAttribute(node, abstract ? "abstractNumId" : "numId"));
+        const map = abstract ? this.abstracts : this.instances;
+        map.set(id, [...map.get(id) ?? [], node]);
+        (abstract ? this.reservedAbstracts : this.reservedInstances).add(id);
+      }
+    }
+  }
+  xml;
+  styles;
+  budget;
+  abstracts = /* @__PURE__ */ new Map();
+  instances = /* @__PURE__ */ new Map();
+  newAbstracts = [];
+  newInstances = [];
+  rebindings = /* @__PURE__ */ new Map();
+  #roots = [];
+  #children = /* @__PURE__ */ new WeakMap();
+  #attributes = /* @__PURE__ */ new WeakMap();
+  #scalarText = /* @__PURE__ */ new WeakSet();
+  #stylesById;
+  #restarts = /* @__PURE__ */ new Map();
+  reservedInstances = /* @__PURE__ */ new Set();
+  reservedAbstracts = /* @__PURE__ */ new Set();
+  project(root) {
+    if (root.namespace !== this.xml.root.namespace || this.#children.has(root)) return;
+    this.budget.charge("retainedBytes", 24);
+    const stack = [{ content: new MarkupCompatibility(root, void 0, this.budget).content, position: 0 }];
+    while (stack.length) {
+      const frame = stack.at(-1);
+      if (frame.position === frame.content.length) {
+        stack.pop();
+        continue;
+      }
+      const item = frame.content[frame.position++];
+      this.budget.charge("work", 1);
+      if ("source" in item && item.disposition === "understood") {
+        this.budget.charge("work", 1 + item.content.length);
+        this.budget.charge("retainedBytes", 96 + item.content.length * 8);
+        this.#children.set(item.source, item.content.filter((node) => "source" in node).map((node) => node.source));
+        this.#attributes.set(item.source, item.attributes);
+        for (const token of item.content) if (!("source" in token) && (token.kind === "text" || token.kind === "cdata")) {
+          this.budget.charge("work", token.text.length);
+          for (const char of token.text) if (!" 	\r\n".includes(char)) {
+            this.#scalarText.add(item.source);
+            break;
+          }
+        }
+        if (item.content.length) {
+          this.budget.charge("retainedBytes", 24);
+          stack.push({ content: item.content, position: 0 });
+        }
+      }
+    }
+  }
+  children(node) {
+    this.budget.charge("work", 1);
+    return node ? this.#children.get(node) ?? [] : [];
+  }
+  child(node, name) {
+    const children = this.children(node).filter((child) => child.namespace === node.namespace && child.localName === name);
+    if (children.length > 1) throw new UnsupportedEditError("Duplicate numbering properties are ambiguous.");
+    return children[0];
+  }
+  reserve(root) {
+    this.#roots.push(root);
+    this.project(root);
+    this.budget.charge("retainedBytes", 8);
+    const stack = [root];
+    while (stack.length) {
+      const node = stack.pop();
+      this.budget.charge("work", 1);
+      if (node.namespace === this.xml.root.namespace && ["numId", "abstractNumId"].includes(node.localName)) {
+        const value = numberingAttribute(node);
+        if (value !== void 0) {
+          const id = nonnegativeInteger(value);
+          if (id !== void 0) (node.localName === "numId" ? this.reservedInstances : this.reservedAbstracts).add(id);
+          else if (this.#children.has(node)) integer(value);
+        }
+      }
+      if (node.namespace === this.xml.root.namespace && ["num", "abstractNum"].includes(node.localName)) {
+        const abstract = node.localName === "abstractNum";
+        const id = nonnegativeInteger(numberingAttribute(node, abstract ? "abstractNumId" : "numId"));
+        if (id !== void 0) (abstract ? this.reservedAbstracts : this.reservedInstances).add(id);
+      }
+      this.budget.charge("work", node.children.length);
+      this.budget.charge("retainedBytes", node.children.length * 8);
+      for (let index = node.children.length - 1; index >= 0; index--) stack.push(node.children[index]);
+    }
+  }
+  style(id, type) {
+    this.budget.charge("work", 1);
+    if (!this.#stylesById) {
+      const definitions = /* @__PURE__ */ new Map();
+      for (const node of this.children(this.styles)) {
+        this.budget.charge("work", 1);
+        if (node.namespace !== this.xml.root.namespace || node.localName !== "style") continue;
+        const key = numberingAttribute(node, "styleId");
+        if (key === void 0) continue;
+        this.budget.charge("retainedBytes", 64);
+        const matches = definitions.get(key);
+        if (matches) matches.push(node);
+        else definitions.set(key, [node]);
+      }
+      this.#stylesById = definitions;
+    }
+    const found = this.#stylesById.get(id) ?? [];
+    if (found.length !== 1 || (numberingAttribute(found[0], "type") ?? "paragraph") !== type) throw new UnsupportedEditError("Numbering style reference is missing or ambiguous.");
+    return found[0];
+  }
+  paragraph(node) {
+    let props = this.child(node, "pPr");
+    let id;
+    const level = numberingAttribute(this.child(this.child(props, "numPr"), "ilvl"));
+    const seen = /* @__PURE__ */ new Set();
+    let style = numberingAttribute(this.child(props, "pStyle"));
+    if (style === void 0) {
+      const defaults = this.children(this.styles).filter((n) => n.namespace === node.namespace && n.localName === "style" && (numberingAttribute(n, "type") ?? "paragraph") === "paragraph" && storedBoolean(numberingAttribute(n, "default") ?? "0"));
+      if (defaults.length > 1) throw new UnsupportedEditError("Ambiguous default paragraph style.");
+      style = numberingAttribute(defaults[0], "styleId");
+    }
+    for (; ; ) {
+      this.budget.charge("work", 1);
+      const numbering = this.child(props, "numPr");
+      if (numbering) {
+        this.attributes(numbering, []);
+        for (const reference of this.children(numbering)) {
+          if (reference.namespace !== node.namespace || !["numId", "ilvl"].includes(reference.localName)) throw new UnsupportedEditError("Unsupported paragraph numbering content cannot be interpreted.");
+          this.child(numbering, reference.localName);
+          this.scalar(reference, ["val"]);
+          integer(numberingAttribute(reference), reference.localName === "ilvl" ? 8 : Number.MAX_SAFE_INTEGER);
+        }
+      }
+      id ??= numberingAttribute(this.child(numbering, "numId"));
+      if (style === void 0) break;
+      if (seen.has(style)) throw new UnsupportedEditError("Paragraph numbering style cycle.");
+      seen.add(style);
+      const definition = this.style(style, "paragraph");
+      props = this.child(definition, "pPr");
+      style = numberingAttribute(this.child(definition, "basedOn"));
+    }
+    if (id === void 0 || integer(id) === 0) return void 0;
+    if (level !== void 0) return { id: integer(id), level: integer(level, 8) };
+    if (seen.size) {
+      const resolved = this.resolve(integer(id));
+      for (const style2 of seen) {
+        const matches = [...resolved.levels].filter(([, n]) => numberingAttribute(this.child(n, "pStyle")) === style2);
+        if (matches.length > 1) throw new UnsupportedEditError("A paragraph style maps to multiple numbering levels.");
+        if (matches.length === 1) return { id: integer(id), level: matches[0][0] };
+      }
+    }
+    return { id: integer(id), level: 0 };
+  }
+  resolve(id, seen = /* @__PURE__ */ new Set()) {
+    const pending = [];
+    let inherited;
+    for (; ; ) {
+      this.budget.charge("work", 1);
+      if (seen.has(id) || seen.size >= this.budget.limits.xmlDepth) throw new UnsupportedEditError("Cyclic or excessively deep numbering style links.");
+      seen.add(id);
+      const instances = this.instances.get(id);
+      if (id === 0 || instances?.length !== 1) throw new UnsupportedEditError("Numbering instance is missing or ambiguous.");
+      const num = instances[0];
+      this.attributes(num, ["numId"]);
+      const reference = this.child(num, "abstractNumId");
+      if (reference) this.scalar(reference, ["val"]);
+      const definitions = this.abstracts.get(integer(numberingAttribute(reference)));
+      if (definitions?.length !== 1) throw new UnsupportedEditError("Abstract numbering definition is missing or ambiguous.");
+      const definition = definitions[0];
+      this.attributes(definition, ["abstractNumId"]);
+      this.budget.charge("retainedBytes", 64);
+      pending.push({ num, definition });
+      const link = numberingAttribute(this.child(definition, "numStyleLink"));
+      if (link === void 0) break;
+      const style = this.style(link, "numbering");
+      const binding = this.child(this.child(this.child(style, "pPr"), "numPr"), "numId");
+      id = integer(numberingAttribute(binding));
+    }
+    while (pending.length) {
+      const frame = pending.pop(), num = frame.num, definition = inherited?.definition ?? frame.definition;
+      const styleLink = numberingAttribute(this.child(definition, "styleLink"));
+      if (styleLink !== void 0) this.style(styleLink, "numbering");
+      const levels = /* @__PURE__ */ new Map();
+      for (const node of this.children(definition)) {
+        this.budget.charge("work", 1);
+        if (node.namespace !== definition.namespace) throw new UnsupportedEditError("Extended numbering definitions cannot be edited.");
+        if (node.localName !== "lvl") {
+          if (!["nsid", "multiLevelType", "tmpl", "name", "styleLink"].includes(node.localName)) throw new UnsupportedEditError("Unsupported numbering definition cannot be edited.");
+          continue;
+        }
+        const index = integer(numberingAttribute(node, "ilvl"), 8);
+        if (levels.has(index)) throw new UnsupportedEditError("Duplicate numbering levels.");
+        this.validateLevel(node, index);
+        levels.set(index, node);
+      }
+      if (inherited) for (const [index, node] of inherited.levels) levels.set(index, node);
+      const overrides = new Map(inherited?.overrides);
+      const starts = new Map(inherited?.starts);
+      const local = /* @__PURE__ */ new Set();
+      for (const node of this.children(num)) {
+        this.budget.charge("work", 1);
+        if (node.namespace !== num.namespace || !["abstractNumId", "lvlOverride"].includes(node.localName)) throw new UnsupportedEditError("Unsupported numbering instance cannot be edited.");
+        if (node.localName !== "lvlOverride") continue;
+        this.attributes(node, ["ilvl"]);
+        const index = integer(numberingAttribute(node, "ilvl"), 8);
+        if (local.has(index) || !levels.has(index)) throw new UnsupportedEditError("Duplicate or unresolved numbering override.");
+        local.add(index);
+        const start = this.child(node, "startOverride");
+        if (start) {
+          this.scalar(start, ["val"]);
+          integer(numberingAttribute(start));
+          starts.set(index, start);
+        }
+        const level = this.child(node, "lvl");
+        if (level) this.validateLevel(level, index);
+        if (this.children(node).some((c) => c.namespace !== node.namespace || !["startOverride", "lvl"].includes(c.localName))) throw new UnsupportedEditError("Unsupported numbering override.");
+        overrides.set(index, node);
+      }
+      for (const [index, node] of overrides) {
+        const level = this.child(node, "lvl");
+        if (level) levels.set(index, level);
+      }
+      for (const start of levels.keys()) {
+        const seen2 = /* @__PURE__ */ new Set();
+        let current = start;
+        while (current !== void 0 && levels.has(current)) {
+          this.budget.charge("work", 1);
+          if (seen2.has(current)) throw new UnsupportedEditError("Cyclic numbering restart dependency.");
+          seen2.add(current);
+          const restart = this.child(levels.get(current), "lvlRestart"), ordinal = restart ? integer(numberingAttribute(restart), 9) : 0;
+          current = ordinal === 0 ? void 0 : ordinal - 1;
+        }
+      }
+      inherited = { num, definition, levels, overrides, starts };
+    }
+    return inherited;
+  }
+  attributes(node, allowed) {
+    if ((this.#attributes.get(node) ?? node.attributes).some((a) => a.namespace !== "http://www.w3.org/2000/xmlns/" && (a.namespace !== node.namespace || !allowed.includes(a.localName)))) throw new UnsupportedEditError("Unverified numbering attributes cannot be interpreted.");
+  }
+  scalar(node, allowed) {
+    this.attributes(node, allowed);
+    if (this.children(node).length || this.#scalarText.has(node)) throw new UnsupportedEditError("Active content in a scalar numbering property cannot be interpreted.");
+  }
+  validateLevel(node, index) {
+    this.attributes(node, ["ilvl", "tentative"]);
+    if (integer(numberingAttribute(node, "ilvl"), 8) !== index) throw new UnsupportedEditError("Override level differs from its owner.");
+    const format = numberingAttribute(this.child(node, "numFmt"));
+    if (!numberingFormats.includes(format) || !this.child(node, "lvlText")) throw new UnsupportedEditError("Unsupported numbering scheme cannot be edited.");
+    for (const child of this.children(node)) {
+      if (child.namespace !== node.namespace || !["start", "numFmt", "lvlRestart", "pStyle", "isLgl", "suff", "lvlText", "lvlJc", "pPr", "rPr"].includes(child.localName)) throw new UnsupportedEditError("Picture bullets and extended numbering remain opaque.");
+      this.child(node, child.localName);
+      if (!["pPr", "rPr"].includes(child.localName)) this.scalar(child, child.localName === "lvlText" ? ["val", "null"] : ["val"]);
+    }
+    const start = this.child(node, "start");
+    if (start) integer(numberingAttribute(start));
+    const restart = this.child(node, "lvlRestart");
+    if (restart) integer(numberingAttribute(restart), 9);
+    const style = numberingAttribute(this.child(node, "pStyle"));
+    if (style !== void 0) this.style(style, "paragraph");
+  }
+  allocate(abstract) {
+    const reserved = abstract ? this.reservedAbstracts : this.reservedInstances;
+    let id = abstract ? 0 : 1;
+    while (reserved.has(id)) {
+      this.budget.charge("work", 1);
+      id++;
+    }
+    if (!Number.isSafeInteger(id)) throw new UnsupportedEditError("Numbering identifier space exhausted.");
+    reserved.add(id);
+    return id;
+  }
+  definitionXml(formats, id) {
+    const levels = formats.map((kind, i) => `<nl:lvl nl:ilvl="${i}"><nl:start nl:val="1"/><nl:numFmt nl:val="${kind}"/><nl:lvlText nl:val="${kind === "bullet" ? "\u2022" : "%" + (i + 1) + "."}"/></nl:lvl>`).join("");
+    return `<nl:abstractNum xmlns:nl="${this.xml.root.namespace}" nl:abstractNumId="${id}"><nl:multiLevelType nl:val="multilevel"/>${levels}</nl:abstractNum>`;
+  }
+  signature(node, root = false) {
+    this.budget.charge("retainedBytes", 24);
+    const stack = [{ node, position: -1 }], fragments = [];
+    let length = 0;
+    const emit = (fragment) => {
+      this.budget.charge("work", fragment.length);
+      this.budget.charge("retainedBytes", 8 + fragment.length * 2);
+      length += fragment.length;
+      fragments.push(fragment);
+    };
+    while (stack.length) {
+      this.budget.charge("work", 1);
+      const frame = stack.at(-1), current = frame.node;
+      if (frame.position === -1) {
+        this.budget.charge("work", 1 + current.attributes.length + current.content.length);
+        this.budget.charge("retainedBytes", 96 + current.attributes.length * 48);
+        const attributes = current.attributes.filter((a) => a.namespace !== "http://www.w3.org/2000/xmlns/" && !(root && current === node && a.namespace === current.namespace && a.localName === "abstractNumId")).map((a) => [a.namespace, a.localName, a.value]).sort();
+        const header = JSON.stringify([current.namespace, current.localName, attributes]);
+        emit(header.slice(0, -1) + ",[");
+        frame.position = 0;
+      } else if (frame.position < current.content.length) {
+        if (frame.position) emit(",");
+        const content = current.content[frame.position++];
+        if (content.kind === "element") {
+          this.budget.charge("retainedBytes", 24);
+          stack.push({ node: content, position: -1 });
+        } else emit(JSON.stringify(content));
+      } else {
+        emit("]]");
+        stack.pop();
+      }
+    }
+    this.budget.charge("retainedBytes", length * 2);
+    this.budget.charge("work", length);
+    return fragments.join("");
+  }
+  abstract(formats) {
+    const original = parseDocumentXml(new TextEncoder().encode(this.definitionXml(formats, 0)), {}, this.budget).root;
+    const expected = this.signature(original, true);
+    for (const [id2, definitions] of this.abstracts) {
+      if (definitions.length === 1 && this.signature(definitions[0], true) === expected) return id2;
+    }
+    const id = this.allocate(true);
+    this.newAbstracts.push(this.definitionXml(formats, id));
+    return id;
+  }
+  create(kind, start, level) {
+    const w = this.xml.root.namespace;
+    const abstractId = this.abstract(Array.from({ length: 9 }, () => kind));
+    const id = this.allocate(false);
+    this.newInstances.push(`<nl:num xmlns:nl="${w}" nl:numId="${id}"><nl:abstractNumId nl:val="${abstractId}"/><nl:lvlOverride nl:ilvl="${level}"><nl:startOverride nl:val="${start}"/></nl:lvlOverride></nl:num>`);
+    return id;
+  }
+  /** Fork the selected occurrence; retain every effective unedited level and source graph. */
+  setLevels(graph, options) {
+    const w = this.xml.root.namespace, children = (node) => this.children(node);
+    const scalar = (name, value) => `<nl:${name} xmlns:nl="${w}" nl:val="${xmlValue(String(value))}"/>`;
+    const styleId = (name, type) => {
+      const matches = selectNamedStyles(this.children(this.styles).filter((node) => node.namespace === w && node.localName === "style"), name, children, this.budget);
+      if (matches.length !== 1 || (numberingAttribute(matches[0], "type") ?? "paragraph") !== type) throw new InvalidValueError("Expected one named style of the required numbering relationship type.");
+      const id2 = numberingAttribute(matches[0], "styleId");
+      if (!id2) throw new UnsupportedEditError("Numbering styles require a stored style ID.");
+      this.style(id2, type);
+      return id2;
+    };
+    let changed = false;
+    const supplied = new Map((options.levels ?? []).map((level) => [level.level, level]));
+    const restarts = /* @__PURE__ */ new Map();
+    const levelMarkup = /* @__PURE__ */ new Map();
+    const levelOrder = "start numFmt lvlRestart pStyle isLgl suff lvlText lvlJc pPr rPr".split(" ");
+    for (const index of /* @__PURE__ */ new Set([...graph.levels.keys(), ...supplied.keys()])) {
+      this.budget.charge("work", 1);
+      const old = graph.levels.get(index), patch = supplied.get(index);
+      const source = old ? this.xml : new DocumentXmlEditor(new TextEncoder().encode(`<nl:lvl xmlns:nl="${w}" nl:ilvl="${index}"/>`), {}, void 0, this.budget);
+      const node = old ?? source.root, updates = /* @__PURE__ */ new Map();
+      const oldRestart = old && this.child(old, "lvlRestart"), restart = patch?.restartAfter === void 0 ? oldRestart ? integer(numberingAttribute(oldRestart), 9) - 1 : null : patch.restartAfter;
+      restarts.set(index, restart === -1 ? null : restart);
+      if (patch) {
+        changed ||= !old || Number(numberingAttribute(graph.starts.get(index) ?? this.child(old, "start")) ?? 1) !== patch.start || numberingAttribute(this.child(old, "numFmt")) !== patch.format || numberingAttribute(this.child(old, "lvlText")) !== patch.text;
+        updates.set("start", scalar("start", patch.start));
+        updates.set("numFmt", scalar("numFmt", patch.format));
+        updates.set("lvlText", scalar("lvlText", patch.text));
+        if (patch.restartAfter !== void 0) changed ||= patch.restartAfter !== (oldRestart ? Number(numberingAttribute(oldRestart)) - 1 : null);
+        if (patch.paragraphStyle !== void 0) changed ||= styleId(patch.paragraphStyle, "paragraph") !== numberingAttribute(this.child(old, "pStyle"));
+        if (patch.restartAfter !== void 0) updates.set("lvlRestart", patch.restartAfter === null ? "" : scalar("lvlRestart", patch.restartAfter + 1));
+        if (patch.paragraphStyle !== void 0) updates.set("pStyle", scalar("pStyle", styleId(patch.paragraphStyle, "paragraph")));
+        if (patch.indent !== void 0 || patch.hanging !== void 0) {
+          const hanging = patch.hanging === void 0 ? void 0 : paragraphUnits(plainLength(patch.hanging), 1);
+          const props = paragraphProperties(source, node, {
+            ...patch.indent === void 0 ? {} : { leftIndent: { value: paragraphUnits(plainLength(patch.indent), 1), unit: "emu" } },
+            ...hanging === void 0 ? {} : { firstLineIndent: { value: -hanging, unit: "emu" } }
+          }, void 0, old ? children : void 0);
+          const previous = old && this.child(old, "pPr");
+          changed ||= props !== (previous ? source.sourceXml(previous) : "");
+          updates.set("pPr", props);
+        }
+      } else if (graph.starts.has(index)) updates.set("start", scalar("start", numberingAttribute(graph.starts.get(index))));
+      const markup = mergeStyleChildren(source, node, updates, levelOrder, {}, old ? children : void 0);
+      const envelope = runElementOpen({ ...node, attributes: [] }) + markup + `</${node.name}>`;
+      const editor = new DocumentXmlEditor(new TextEncoder().encode(envelope), {}, void 0, this.budget);
+      levelMarkup.set(index, old ? this.fragment(old, editor.sourceXml(editor.root.children[0], /* @__PURE__ */ new Map(), true)) : markup);
+    }
+    for (const start of restarts.keys()) {
+      const seen = /* @__PURE__ */ new Set();
+      let current = start;
+      while (current !== null && current !== void 0 && restarts.has(current)) {
+        this.budget.charge("work", 1);
+        if (seen.has(current)) throw new InvalidValueError("List restart dependencies cannot contain cycles.");
+        seen.add(current);
+        current = restarts.get(current);
+      }
+    }
+    const priorLink = this.child(graph.definition, "styleLink");
+    if (options.numberingStyle !== void 0) changed ||= (options.numberingStyle === null ? void 0 : styleId(options.numberingStyle, "numbering")) !== numberingAttribute(priorLink);
+    if (!changed) return integer(numberingAttribute(graph.num, "numId"));
+    const id = this.allocate(false), abstractId = this.allocate(true), definitionPatches = /* @__PURE__ */ new Map();
+    const originalLevels = /* @__PURE__ */ new Set();
+    for (const old of this.children(graph.definition)) if (old.namespace === w && old.localName === "lvl") {
+      const index = integer(numberingAttribute(old, "ilvl"), 8);
+      originalLevels.add(index);
+      definitionPatches.set(old, levelMarkup.get(index));
+    }
+    const link = this.child(graph.definition, "styleLink"), newLink = options.numberingStyle === void 0 ? void 0 : options.numberingStyle === null ? "" : scalar("styleLink", styleId(options.numberingStyle, "numbering"));
+    if (link && newLink !== void 0) definitionPatches.set(link, newLink);
+    const firstLevel = this.children(graph.definition).find((node) => node.namespace === w && node.localName === "lvl");
+    if (!link && newLink && firstLevel) definitionPatches.set(firstLevel, newLink + definitionPatches.get(firstLevel));
+    const addedLevels = [...levelMarkup].filter(([index]) => !originalLevels.has(index)).sort(([a], [b]) => a - b).map(([, markup]) => markup).join("");
+    const definition = this.fragment(graph.definition, this.xml.sourceXml(graph.definition, definitionPatches, true) + (link || firstLevel || newLink === void 0 ? "" : newLink) + addedLevels);
+    const definitionEditor = new DocumentXmlEditor(new TextEncoder().encode(definition), {}, void 0, this.budget);
+    this.newAbstracts.push(mergeStyleChildren(definitionEditor, definitionEditor.root, /* @__PURE__ */ new Map(), [], { abstractNumId: String(abstractId) }));
+    const numPatches = /* @__PURE__ */ new Map([[this.child(graph.num, "abstractNumId"), scalar("abstractNumId", abstractId)]]);
+    for (const override of this.children(graph.num)) if (override.namespace === w && override.localName === "lvlOverride") numPatches.set(override, mergeStyleChildren(this.xml, override, /* @__PURE__ */ new Map([["startOverride", ""], ["lvl", ""]]), ["startOverride", "lvl"], {}, children));
+    const num = this.fragment(graph.num, this.xml.sourceXml(graph.num, numPatches, true)), numEditor = new DocumentXmlEditor(new TextEncoder().encode(num), {}, void 0, this.budget);
+    this.newInstances.push(mergeStyleChildren(numEditor, numEditor.root, /* @__PURE__ */ new Map(), [], { numId: String(id) }));
+    return id;
+  }
+  mixUnusedLevel(graph, level, kind) {
+    const reference = this.child(graph.num, "abstractNumId");
+    if (integer(numberingAttribute(reference)) !== integer(numberingAttribute(graph.definition, "abstractNumId")) || this.child(graph.overrides.get(level), "lvl")) return false;
+    const formats = Array.from({ length: 9 }, (_, i) => numberingAttribute(this.child(graph.levels.get(i), "numFmt")) ?? "");
+    if (formats.some((format) => !numberingFormats.includes(format))) return false;
+    const template = parseDocumentXml(new TextEncoder().encode(this.definitionXml(formats, 0)), {}, this.budget).root;
+    if (this.signature(graph.definition, true) !== this.signature(template, true)) return false;
+    const id = integer(numberingAttribute(graph.num, "numId"));
+    let used = false;
+    for (const root of this.#roots) {
+      if (used) break;
+      this.budget.charge("retainedBytes", 24);
+      const stack = [{ node: root, ancestors: [] }];
+      while (stack.length) {
+        const { node, ancestors } = stack.pop();
+        this.budget.charge("work", 1);
+        if (node.namespace === this.xml.root.namespace && node.localName === "p") {
+          const binding = this.paragraph(node);
+          if (binding?.id === id && binding.level === level) used = true;
+        }
+        if (node.namespace === this.xml.root.namespace && node.localName === "numId" && nonnegativeInteger(numberingAttribute(node)) === id && (!this.#children.has(node) || ancestors.at(-3)?.localName !== "p")) used = true;
+        if (!used && node.children.length) {
+          this.budget.charge("work", node.children.length);
+          this.budget.charge("retainedBytes", 24 + node.children.length * 24);
+          const parents = [...ancestors.slice(-2), node];
+          for (let index = node.children.length - 1; index >= 0; index--) stack.push({ node: node.children[index], ancestors: parents });
+        }
+      }
+    }
+    if (used) return false;
+    formats[level] = kind;
+    const abstractId = this.abstract(formats);
+    this.rebindings.set(graph.num, this.xml.sourceXml(graph.num, /* @__PURE__ */ new Map([[
+      reference,
+      `<nl:abstractNumId xmlns:nl="${this.xml.root.namespace}" nl:val="${abstractId}"/>`
+    ]])));
+    return true;
+  }
+  restart(graph, level, start) {
+    let draft = this.#restarts.get(graph.num);
+    if (!draft) {
+      draft = { id: this.allocate(false), position: this.newInstances.length, starts: /* @__PURE__ */ new Map() };
+      this.#restarts.set(graph.num, draft);
+      this.newInstances.push("");
+    }
+    draft.starts.set(level, start);
+    const id = draft.id, w = this.xml.root.namespace;
+    const overrides = /* @__PURE__ */ new Map();
+    const all = /* @__PURE__ */ new Set([...graph.overrides.keys(), ...draft.starts.keys()]);
+    for (const index of all) {
+      const old = graph.overrides.get(index);
+      const startNode = graph.starts.get(index);
+      const startXml = startNode ? this.fragment(startNode, this.xml.sourceXml(startNode, /* @__PURE__ */ new Map(), true), draft.starts.get(index)) : draft.starts.has(index) ? `<nl:startOverride xmlns:nl="${w}" nl:val="${draft.starts.get(index)}"/>` : "";
+      const effective = graph.levels.get(index);
+      const definitionLevel = this.children(graph.definition).find((n) => n.namespace === w && n.localName === "lvl" && integer(numberingAttribute(n, "ilvl"), 8) === index);
+      const levelXml = effective === definitionLevel ? "" : effective === this.child(old, "lvl") ? this.xml.sourceXml(effective) : this.fragment(effective, this.xml.sourceXml(effective, /* @__PURE__ */ new Map(), true));
+      if (old) {
+        const priorStart = this.child(old, "startOverride"), priorLevel = this.child(old, "lvl");
+        const patches = /* @__PURE__ */ new Map();
+        if (priorStart) patches.set(priorStart, startXml);
+        if (priorLevel) patches.set(priorLevel, (priorStart ? "" : startXml) + levelXml);
+        const tail = (priorStart || priorLevel ? "" : startXml) + (priorLevel ? "" : levelXml);
+        const rewrite = (node) => {
+          const pending = [{ node, position: 0, changed: /* @__PURE__ */ new Map() }];
+          this.budget.charge("retainedBytes", 64);
+          while (pending.length) {
+            const frame = pending.at(-1);
+            if (frame.position === 0) this.budget.charge("work", 1);
+            if (!patches.has(frame.node) && frame.position < frame.node.children.length) {
+              this.budget.charge("retainedBytes", 64);
+              pending.push({ node: frame.node.children[frame.position++], position: 0, changed: /* @__PURE__ */ new Map() });
+              continue;
+            }
+            const replacement = patches.has(frame.node) ? patches.get(frame.node) : frame.changed.size ? this.xml.sourceXml(frame.node, frame.changed) : void 0;
+            pending.pop();
+            if (!pending.length) return replacement;
+            if (replacement !== void 0) {
+              this.budget.charge("retainedBytes", 16);
+              pending.at(-1).changed.set(frame.node, replacement);
+            }
+          }
+          return void 0;
+        };
+        const direct = /* @__PURE__ */ new Map();
+        for (const child of old.children) {
+          const replacement = rewrite(child);
+          if (replacement !== void 0) direct.set(child, replacement);
+        }
+        overrides.set(index, this.fragment(old, this.xml.sourceXml(old, direct, true) + tail));
+      } else overrides.set(index, `<nl:lvlOverride xmlns:nl="${w}" nl:ilvl="${index}">${startXml}${levelXml}</nl:lvlOverride>`);
+    }
+    this.newInstances[draft.position] = `<nl:num xmlns:nl="${w}" nl:numId="${id}"><nl:abstractNumId nl:val="${xmlValue(numberingAttribute(graph.definition, "abstractNumId"))}"/>${[...overrides].sort(([a], [b]) => a - b).map(([, xml]) => xml).join("")}</nl:num>`;
+    return id;
+  }
+  /** Bind inherited compatibility names before relocating a numbering fragment. */
+  fragment(node, content, value) {
+    const pending = [{ node: this.xml.root, position: 0 }];
+    this.budget.charge("work", 1);
+    this.budget.charge("retainedBytes", 24);
+    while (pending.length) {
+      const frame = pending.at(-1);
+      if (frame.node === node) break;
+      if (frame.position === frame.node.children.length) {
+        pending.pop();
+        continue;
+      }
+      this.budget.charge("work", 1);
+      this.budget.charge("retainedBytes", 24);
+      pending.push({ node: frame.node.children[frame.position++], position: 0 });
+    }
+    if (!pending.length) throw new UnsupportedEditError("Numbering fragment has no source owner.");
+    this.budget.charge("retainedBytes", pending.length * 8);
+    const chain = pending.map((frame) => frame.node);
+    const mc = "http://schemas.openxmlformats.org/markup-compatibility/2006";
+    const bindings = new Map(node.namespaces), controls = /* @__PURE__ */ new Map();
+    const prefixFor = (uri) => {
+      this.budget.charge("work", bindings.size);
+      for (const [prefix2, namespace] of bindings) if (prefix2 && namespace === uri) return prefix2;
+      let index = 0;
+      while (bindings.has(`ctx${index}`)) {
+        this.budget.charge("work", 1);
+        index++;
+      }
+      const prefix = `ctx${index}`;
+      bindings.set(prefix, uri);
+      return prefix;
+    };
+    for (const ancestor of chain) for (const attribute of ancestor.attributes) {
+      this.budget.charge("work", 1 + attribute.value.length);
+      if (attribute.namespace !== mc) continue;
+      const values = controls.get(attribute.localName) ?? /* @__PURE__ */ new Set();
+      for (const token of attribute.value.split("	").join(" ").split("\r").join(" ").split("\n").join(" ").split(" ").filter(Boolean)) {
+        const [prefix, local] = token.split(":");
+        const uri = ancestor.namespaces.get(prefix);
+        if (!uri) throw new UnsupportedEditError("Unbound numbering compatibility name.");
+        values.add(prefixFor(uri) + (local === void 0 ? "" : ":" + local));
+      }
+      controls.set(attribute.localName, values);
+    }
+    const attributes = node.attributes.filter((attribute) => attribute.namespace !== mc).map((attribute) => value !== void 0 && attribute.namespace === node.namespace && attribute.localName === "val" ? { ...attribute, value: String(value) } : attribute);
+    for (const [localName, values] of controls) attributes.push({ name: prefixFor(mc) + ":" + localName, namespace: mc, localName, value: [...values].join(" ") });
+    const result = runElementOpen({ ...node, namespaces: bindings, attributes }) + content + `</${node.name}>`;
+    this.budget.charge("retainedBytes", result.length * 2);
+    this.budget.charge("work", result.length);
+    return result;
+  }
+  flush() {
+    const additions = this.newAbstracts.join("");
+    const instances = this.newInstances.join("");
+    if (!additions && !instances && !this.rebindings.size) return this.xml.serialize();
+    const root = this.xml.root;
+    const active = new Set(activeXmlChildren(this.xml, this.budget)(root));
+    const alternatives = new Set(this.xml.compatibility.branches.map((branch) => branch.alternateContent));
+    this.budget.charge("retainedBytes", 128 + (active.size + alternatives.size) * 16);
+    const ranks = /* @__PURE__ */ new Map();
+    for (const node of root.children) {
+      const found = /* @__PURE__ */ new Set();
+      this.budget.charge("retainedBytes", 24);
+      const stack = [{ node, alternate: false }];
+      while (stack.length) {
+        const { node: current, alternate } = stack.pop();
+        this.budget.charge("work", 1);
+        if (current.namespace === root.namespace) {
+          const rank = ["numPicBullet", "abstractNum", "num", "numIdMacAtCleanup"].indexOf(current.localName);
+          if (rank >= 0) {
+            if (alternate || active.has(current)) found.add(rank);
+            continue;
+          }
+        }
+        this.budget.charge("work", current.children.length);
+        this.budget.charge("retainedBytes", current.children.length * 24);
+        for (let index = current.children.length - 1; index >= 0; index--) stack.push({ node: current.children[index], alternate: alternate || alternatives.has(current) });
+      }
+      this.budget.charge("retainedBytes", 96 + found.size * 16);
+      ranks.set(node, [...found]);
+    }
+    const boundary = (rank) => {
+      const node = root.children.find((node2) => ranks.get(node2).some((value) => value > rank));
+      if (node && ranks.get(node).some((value) => value < rank))
+        throw new UnsupportedEditError("Numbering insertion would split a retained compatibility representation.");
+      return node;
+    };
+    const firstNum = additions ? boundary(1) : void 0;
+    const cleanup = instances ? boundary(2) : void 0;
+    const patches = new Map(this.rebindings);
+    if (firstNum) patches.set(firstNum, additions + (patches.get(firstNum) ?? this.xml.sourceXml(firstNum)));
+    if (cleanup) patches.set(cleanup, (firstNum === cleanup ? additions : "") + instances + (this.rebindings.get(cleanup) ?? this.xml.sourceXml(cleanup)));
+    const content = this.xml.sourceXml(root, patches, true) + (firstNum ? "" : additions) + (cleanup ? "" : instances);
+    const original = this.xml.serialize();
+    const encoding = original[0] === 255 && original[1] === 254 ? "UTF-16LE" : original[0] === 254 && original[1] === 255 ? "UTF-16BE" : "UTF-8";
+    const [prolog, epilog] = this.xml[sourceRootEnvelope]();
+    const rewritten = prolog + runElementOpen(root) + content + `</${root.name}>` + epilog;
+    this.budget.check("xmlPartBytes", rewritten.length * (encoding === "UTF-8" ? 1 : 2));
+    this.budget.charge("retainedBytes", rewritten.length * 3);
+    this.budget.charge("work", rewritten.length * 3);
+    let bytes;
+    if (encoding === "UTF-8") bytes = new TextEncoder().encode(rewritten);
+    else {
+      bytes = new Uint8Array(rewritten.length * 2);
+      const view = new DataView(bytes.buffer);
+      for (let index = 0; index < rewritten.length; index++) view.setUint16(index * 2, rewritten.charCodeAt(index), encoding === "UTF-16LE");
+    }
+    const editor = new DocumentXmlEditor(bytes, {}, void 0, this.budget);
+    this.budget.charge("insertedNodes", parseDocumentXml(new TextEncoder().encode(`<root${[...root.namespaces].filter(([p]) => p !== "xml").map(([p, uri]) => ` ${p ? "xmlns:" + p : "xmlns"}="${xmlValue(uri)}"`).join("")}>${additions}${instances}</root>`), {}, this.budget).root.children.reduce((total, n) => total + countNodes(n, this.budget), 0));
+    return editor.serialize();
+  }
+};
+function countNodes(node, budget) {
+  const pending = [node];
+  budget.charge("retainedBytes", 8);
+  let count = 0;
+  while (pending.length) {
+    const current = pending.pop();
+    budget.charge("work", 1 + current.children.length);
+    budget.charge("retainedBytes", current.children.length * 8);
+    count++;
+    for (const child of current.children) pending.push(child);
+  }
+  return count;
+}
+
+// packages/safe-bash-docx-engine/src/lists.ts
+async function editDocumentLists(input, request, context) {
+  closedRecord(request, ["operation", "options", "input"]);
+  if (!["lists.add", "lists.set"].includes(request.operation)) throw new DocxUsageError("Expected a list 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 packageGraph = new DocumentPackage(archive, settings.limits, budget);
+  const mainPart = packageGraph.getPart(document.list("story", { scope: "body" })[0].value.part);
+  const main = mainPart.name;
+  const dialect = dialectForNamespace(parseDocumentXml(mainPart.bytes, {}, budget).root.namespace);
+  const { w, r } = documentDialects[dialect];
+  const edges = packageGraph.relationships("/" + main);
+  const numberingEdges = edges.filter((e) => e.reltype === r + "/numbering");
+  const stylesEdges = edges.filter((e) => e.reltype === r + "/styles");
+  if (numberingEdges.length > 1 || stylesEdges.length > 1 || numberingEdges[0]?.is_external || stylesEdges[0]?.is_external)
+    throw new UnsupportedEditError("Numbering and style ownership must be unambiguous and internal.");
+  let numberingName = numberingEdges[0]?.target_part.name;
+  const numbering = new DocumentXmlEditor(numberingEdges[0]?.target_part.bytes ?? new TextEncoder().encode(`<nl:numbering xmlns:nl="${w}"/>`), {}, void 0, budget);
+  if (numbering.root.namespace !== w) throw new UnsupportedEditError("Numbering dialect does not match its owner.");
+  const styles = stylesEdges[0] ? parseDocumentXml(stylesEdges[0].target_part.bytes, {}, budget).root : void 0;
+  const graph = new NumberingGraph(numbering, styles, budget);
+  for (const member of archive.members) if (member.name.endsWith(".xml")) graph.reserve(parseDocumentXml(member.bytes, {}, budget).root);
+  const editors = /* @__PURE__ */ new Map();
+  const updates = [];
+  for (const before of selected) {
+    await budget.checkpoint();
+    budget.charge("work", 1);
+    const part = packageGraph.getPart(before.value.part).name;
+    let xml = editors.get(part);
+    if (!xml) {
+      xml = new DocumentXmlEditor(archive.members.find((m) => m.name === part).bytes, {}, void 0, budget);
+      editors.set(part, xml);
+      graph.project(xml.root);
+    }
+    let node = xml.root;
+    const ancestors = [node];
+    for (const position of before.value.path) {
+      node = node.children[position];
+      ancestors.push(node);
+    }
+    if (ancestors.some((n) => n.namespace === w && (["ins", "del", "moveFrom", "moveTo"].includes(n.localName) || graph.child(graph.child(n, "pPr"), "pPrChange"))))
+      throw new UnsupportedEditError("Tracked list paragraphs require revision operations.");
+    if (node.namespace !== w || !["p", "body", "tc", "hdr", "ftr", "footnote", "endnote", "comment", "txbxContent"].includes(node.localName)) throw new UnsupportedEditError("Expected a supported list paragraph or block container.");
+    let previous = node.localName === "p" ? node : graph.children(node).filter((n) => n.namespace === w && n.localName === "p").at(-1);
+    if (request.operation === "lists.set") previous = node;
+    const existing = previous ? graph.paragraph(previous) : void 0;
+    const level = options.level ?? (request.operation === "lists.set" ? existing?.level ?? 0 : 0);
+    let id;
+    if (request.operation === "lists.set") {
+      if (node.localName !== "p" || !existing) throw new UnsupportedEditError("List set requires an existing list paragraph.");
+      const resolved = graph.resolve(existing.id);
+      if (!resolved.levels.has(level) || !resolved.levels.has(existing.level)) throw new UnsupportedEditError("The selected numbering level has no definition.");
+      id = existing.id;
+      if (options.restart) {
+        const start = options.start ?? Number(numberingAttribute(graph.child(resolved.levels.get(level), "start")) ?? 1);
+        id = graph.restart(resolved, level, start);
+      }
+      if (id === existing.id && level === existing.level) continue;
+      assertFormattingHistoryEditable(xml.root, node, activeXmlChildren(xml, budget), budget);
+      const props = graph.child(node, "pPr");
+      const markup = listProperties(xml, props, id, level, w, graph);
+      if (props) xml[replaceListPropertyXml](props, markup);
+      else xml.insertChildren(node, markup, node.children[0]);
+      updates.push({ before, path: before.value.path, kind: "format" });
+    } else {
+      assertFormattingHistoryEditable(xml.root, node, activeXmlChildren(xml, budget), budget);
+      id = 0;
+      if (existing && options.start === void 0) {
+        const resolved = graph.resolve(existing.id);
+        if (!resolved.levels.has(existing.level)) throw new UnsupportedEditError("The preceding numbering level has no definition.");
+        if (numberingAttribute(graph.child(resolved.levels.get(level), "numFmt")) === options.kind || graph.mixUnusedLevel(resolved, level, options.kind)) id = existing.id;
+      }
+      if (!id) id = graph.create(options.kind, options.start ?? 1, level);
+      const markup = `<nl:p xmlns:nl="${w}">${listProperties(void 0, void 0, id, level, w)}${paragraphTextRun(w, options.text ?? "")}</nl:p>`;
+      if (node.localName === "p") {
+        const carriers = new Set(xml.compatibility[compatibilityContainers]);
+        const container = ancestors.slice(0, -1).reverse().find((ancestor) => !carriers.has(ancestor));
+        if (container.namespace !== w || !["body", "tc", "hdr", "ftr", "footnote", "endnote", "comment", "txbxContent", "sdtContent"].includes(container.localName)) throw new UnsupportedEditError("List insertion requires a supported block container.");
+        if (numberingChild(numberingChild(node, "pPr"), "sectPr")) throw new UnsupportedEditError("Insert lists at a block container when the anchor ends a section.");
+        const path = xml[insertParagraphAfter](node, markup, before.value.path);
+        updates.push({ before, path, kind: "insert" });
+      } else {
+        const section = numberingChild(node, "sectPr");
+        xml.insertChildren(node, markup, section);
+        updates.push({ before, path: [...before.value.path, section ? node.children.indexOf(section) : node.children.length], kind: "insert" });
+      }
+    }
+  }
+  archive = { ...archive, members: archive.members.map((m) => editors.has(m.name) ? { ...m, bytes: editors.get(m.name).serialize() } : m) };
+  if (graph.newAbstracts.length || graph.newInstances.length || graph.rebindings.size) {
+    const bytes = graph.flush();
+    if (!numberingName) {
+      const name = packageGraph.allocatePartName("/word/numbering", ".xml");
+      numberingName = name.slice(1);
+      const types = archive.members.find((m) => m.name === "[Content_Types].xml");
+      const typesXml = new DocumentXmlEditor(types.bytes, {}, void 0, budget);
+      typesXml.insertChildren(typesXml.root, `<Override xmlns="http://schemas.openxmlformats.org/package/2006/content-types" PartName="${xmlValue(name)}" ContentType="application/vnd.openxmlformats-officedocument.wordprocessingml.numbering+xml"/>`);
+      const split = main.lastIndexOf("/");
+      const relName = findRelationshipPart(packageGraph, "/" + main, budget)?.name ?? main.slice(0, split + 1) + "_rels/" + main.slice(split + 1) + ".rels";
+      const member = archive.members.find((m) => m.name === relName);
+      const ns = "http://schemas.openxmlformats.org/package/2006/relationships";
+      const relXml = new DocumentXmlEditor(member?.bytes ?? new TextEncoder().encode(`<Relationships xmlns="${ns}"/>`), {}, void 0, budget);
+      relXml.insertChildren(relXml.root, `<Relationship xmlns="${ns}" Id="${packageGraph.allocateRelationshipId("/" + main)}" Type="${r}/numbering" Target="${xmlValue(relativePartTarget("/" + main, name))}"/>`);
+      const members = archive.members.map((m) => m === types ? { ...m, bytes: typesXml.serialize() } : m === member ? { ...m, bytes: relXml.serialize() } : m);
+      if (!member) members.push({ name: relName, bytes: relXml.serialize(), directory: false, modified: /* @__PURE__ */ new Date("1980-01-01T00:00:00Z") });
+      members.push({ name: numberingName, bytes, directory: false, modified: /* @__PURE__ */ new Date("1980-01-01T00:00:00Z") });
+      archive = { ...archive, members };
+    } else archive = { ...archive, members: archive.members.map((m) => m.name === numberingName ? { ...m, bytes } : m) };
+  }
+  const index = new LocationIndex(archive, settings.limits, main, dialect, budget);
+  const changes = updates.map(({ before, path, kind }) => {
+    const entry = index.byAddress.get(addressKey({ ...before.value, path }))?.find((e) => e.kind === "paragraph");
+    if (!entry) throw new UnsupportedEditError("List edit could not resolve its resulting paragraph.");
+    const value = { ...before.value, generation: 1, path, range: null };
+    const after = { kind: "paragraph", value, token: encodeGeneratedLocation(value), positions: entry.positions };
+    return { kind, 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.length > 0, 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.length > 0, changes, dryRun: options.dryRun ?? false, output: result.published.length ? { path: result.published[0].path, bytes: result.published[0].bytes, sha256: result.archiveSha256 } : null };
+}
+function listProperties(xml, props, id, level, w, graph) {
+  const children = (node) => graph ? graph.children(node) : node?.children ?? [];
+  const find = (node, name) => graph ? graph.child(node, name) : numberingChild(node, name);
+  const old = find(props, "numPr");
+  if (children(old).some((c) => c.namespace !== w || !["ilvl", "numId"].includes(c.localName))) throw new UnsupportedEditError("Tracked or extended list references cannot be edited.");
+  const priorLevel = find(old, "ilvl"), priorId = find(old, "numId");
+  const scalar = (node, name, value) => node && xml ? runElementOpen({ ...node, attributes: node.attributes.map((attribute) => attribute.namespace === w && attribute.localName === "val" ? { ...attribute, value: String(value) } : attribute) }) + xml.sourceXml(node, /* @__PURE__ */ new Map(), true) + `</${node.name}>` : `<nl:${name} xmlns:nl="${w}" nl:val="${value}"/>`;
+  const ilvl = scalar(priorLevel, "ilvl", level), numId = scalar(priorId, "numId", id);
+  let numbering = `<nl:numPr xmlns:nl="${w}">${ilvl}${numId}</nl:numPr>`;
+  if (old && xml) {
+    const patches = /* @__PURE__ */ new Map();
+    if (priorLevel) patches.set(priorLevel, ilvl);
+    if (priorId) patches.set(priorId, (priorLevel ? "" : ilvl) + numId);
+    numbering = runElementOpen(old) + xml.sourceXml(old, patches, true) + (priorId ? "" : (priorLevel ? "" : ilvl) + numId) + `</${old.name}>`;
+  }
+  if (!props || !xml) return `<nl:pPr xmlns:nl="${w}">${numbering}</nl:pPr>`;
+  if (old) return xml.sourceXml(props, /* @__PURE__ */ new Map([[old, numbering]]));
+  const preceding = ["pStyle", "keepNext", "keepLines", "pageBreakBefore", "framePr", "widowControl"];
+  const next = children(props).find((c) => c.namespace === w && !preceding.includes(c.localName));
+  const content = xml.sourceXml(props, next ? /* @__PURE__ */ new Map([[next, numbering + xml.sourceXml(next)]]) : /* @__PURE__ */ new Map(), true) + (next ? "" : numbering);
+  return runElementOpen(props) + content + `</${props.name}>`;
+}
+
+export {
+  NumberingGraph,
+  editDocumentLists,
+  listProperties
+};