@poe-platform/safe-bash 0.1.806 → 0.1.807

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

@@ -0,0 +1,2817 @@
+import {
+  propertyGroupDefinition,
+  readPropertyNodes,
+  storedBoolean,
+  storedBooleanValue,
+  storedIntegerIdentity,
+  trimXmlWhitespace
+} from "./chunk-VEUQWV2V.js";
+import {
+  relationshipXmlRows
+} from "./chunk-2PSVE7I5.js";
+import {
+  dialectForNamespace,
+  documentDialects,
+  validateXmlDialect
+} from "./chunk-MG7AJD5E.js";
+import {
+  styleFontFlags
+} from "./chunk-M57GLLK4.js";
+import {
+  Length,
+  Pt,
+  Twips
+} from "./chunk-R4TYL2G6.js";
+import {
+  MarkupCompatibility,
+  compatibilityContainers,
+  compatibilityProfileForRoot,
+  compatibilitySettings,
+  hasCompatibilityMarkup
+} from "./chunk-GZ2N24A2.js";
+import {
+  OwnershipError
+} from "./chunk-OBK24KGM.js";
+import {
+  InvalidXmlError,
+  documentXmlSettings,
+  parseDocumentXml
+} from "./chunk-MWAAMNAM.js";
+import {
+  DocxUsageError,
+  validFontName
+} from "./chunk-2P7BLWWI.js";
+import {
+  DocumentBudget,
+  InputTypeError,
+  InvalidDocumentError,
+  InvalidValueError,
+  ResourceLimitError,
+  documentXmlCache
+} from "./chunk-IQFRPIXH.js";
+
+// packages/safe-bash-docx-engine/src/xml-active-children.ts
+var projections = /* @__PURE__ */ new WeakMap();
+var immutableProjections = /* @__PURE__ */ new WeakMap();
+function activeXmlChildren(xml2, budget) {
+  let children = projections.get(xml2);
+  if (!children) {
+    const content = "kind" in xml2 ? new MarkupCompatibility(xml2, void 0, budget).content : xml2.compatibility.content;
+    const root = "kind" in xml2 ? xml2 : xml2.root;
+    const cache = budget[documentXmlCache], profiles = cache.compatibility?.get(root);
+    let immutable = false;
+    if (cache.immutableRoots?.has(root) && profiles) {
+      for (const profile of profiles.values()) if (profile.content === content) {
+        immutable = true;
+        break;
+      }
+    }
+    const shared = immutable ? immutableProjections.get(content) : void 0;
+    const constructed = shared ? void 0 : /* @__PURE__ */ new Map();
+    const pending = [{ content, index: 0 }];
+    while (pending.length) {
+      const frame = pending.at(-1);
+      if (frame.index >= frame.content.length) {
+        pending.pop();
+        continue;
+      }
+      const item = frame.content[frame.index++];
+      if (!("source" in item)) continue;
+      budget.charge("retainedBytes", 96 + item.content.length * 8);
+      constructed?.set(
+        item.source,
+        Object.freeze(item.content.filter((node) => "source" in node).map((node) => node.source))
+      );
+      pending.push({ content: item.content, index: 0 });
+    }
+    children = shared ?? constructed;
+    if (immutable && !shared) immutableProjections.set(content, children);
+    projections.set(xml2, children);
+  }
+  return (node) => {
+    budget.charge("work", 1);
+    return children.get(node) ?? [];
+  };
+}
+
+// packages/safe-bash-docx-engine/src/xml-display.ts
+function displayXml(root, budget, pretty) {
+  const chunks = [];
+  let size = 0;
+  const append = (text) => {
+    const bytes = new TextEncoder().encode(text).length;
+    budget.check("serializedOutput", size + bytes);
+    budget.charge("retainedBytes", text.length * 2 + 64);
+    budget.charge("work", text.length);
+    size += bytes;
+    chunks.push(text);
+  };
+  const escaped = (text, attribute = false) => {
+    let chunk = "";
+    for (const char of text) {
+      chunk += char === "&" ? "&amp;" : char === "<" ? "&lt;" : char === ">" ? "&gt;" : char === "\r" ? "&#13;" : attribute && char === '"' ? "&quot;" : attribute && char === "\n" ? "&#10;" : attribute && char === "	" ? "&#9;" : char;
+      if (chunk.length >= 4096) {
+        append(chunk);
+        chunk = "";
+      }
+    }
+    if (chunk) append(chunk);
+  };
+  const visit = (node, depth, preserve) => {
+    budget.charge("retainedBytes", 64);
+    const pending = [{ node, depth, preserve, index: -1, indent: false }];
+    while (pending.length) {
+      const frame = pending.at(-1);
+      const current = frame.node;
+      if (frame.index === -1) {
+        budget.charge("work", 1);
+        if (current.kind !== "element") {
+          if (current.kind === "comment") append("<!--" + current.text + "-->");
+          else if (current.kind === "processing-instruction") append("<?" + current.target + (current.text ? " " + current.text : "") + "?>");
+          else if (current.kind === "cdata") append("<![CDATA[" + current.text + "]]>");
+          else escaped(current.text);
+          pending.pop();
+          continue;
+        }
+        const space = current.attributes.find((a) => a.namespace === "http://www.w3.org/XML/1998/namespace" && a.localName === "space")?.value;
+        frame.preserve = space === "preserve" || space !== "default" && frame.preserve;
+        append("<" + current.name);
+        for (const attr of current.attributes) {
+          append(" " + attr.name + '="');
+          escaped(attr.value, true);
+          append('"');
+        }
+        if (!current.content.length) {
+          append("/>");
+          pending.pop();
+          continue;
+        }
+        append(">");
+        frame.indent = pretty && !frame.preserve && !current.content.some((child2) => child2.kind === "text" || child2.kind === "cdata");
+        frame.index = 0;
+      }
+      if (current.kind !== "element") continue;
+      const child = current.content[frame.index++];
+      if (child) {
+        if (frame.indent) append("\n" + "  ".repeat(frame.depth + 1));
+        budget.charge("retainedBytes", 64);
+        pending.push({ node: child, depth: frame.depth + 1, preserve: frame.preserve, index: -1, indent: false });
+      } else {
+        if (frame.indent) append("\n" + "  ".repeat(frame.depth));
+        append("</" + current.name + ">");
+        pending.pop();
+      }
+    }
+  };
+  if (root.declaration !== void 0) append('<?xml version="1.0" encoding="UTF-8"?>');
+  for (const node of root.prolog ?? []) visit(node, 0, false);
+  visit(root, 0, false);
+  for (const node of root.epilog ?? []) visit(node, 0, false);
+  return chunks.join("");
+}
+
+// packages/safe-bash-docx-engine/src/xml-retention.ts
+function opaqueXmlContent(root, budget, profile) {
+  const view = new MarkupCompatibility(root, profile, budget);
+  const containers = new Set(view[compatibilityContainers]);
+  const records = [];
+  const nativeProperties = (node) => (node.namespace === documentDialects.strict.w || node.namespace === documentDialects.transitional.w) && ["pPr", "rPr", "sectPr", "tabs", "tblPr", "trPr", "tcPr"].includes(node.localName);
+  const path = [];
+  budget.charge("retainedBytes", 128);
+  const pending = [{ node: root, inherited: /* @__PURE__ */ new Map(), propertyContext: false, ordinals: /* @__PURE__ */ new Map(), contentIndex: 0, index: -1 }];
+  while (pending.length) {
+    const frame = pending.at(-1);
+    const node = frame.node;
+    if (frame.index === -1) {
+      const inherited = frame.inherited;
+      budget.charge("work", 1 + node.attributes.length + inherited.size);
+      budget.charge("retainedBytes", (inherited.size + 1) * 48);
+      const context = new Map(inherited);
+      for (const attribute of node.attributes) {
+        if (attribute.namespace !== "http://www.w3.org/XML/1998/namespace" || !["lang", "space", "base"].includes(attribute.localName)) continue;
+        budget.charge("retainedBytes", attribute.localName === "base" ? ((context.get("base")?.length ?? 0) + 1) * 8 : 8);
+        context.set(attribute.localName, attribute.localName === "base" ? [...context.get("base") ?? [], attribute.value] : [attribute.value]);
+      }
+      frame.context = context;
+      const namedStyleFields = (node.namespace === documentDialects.strict.w || node.namespace === documentDialects.transitional.w) && node.localName === "style";
+      frame.namedProperties = nativeProperties(node) || namedStyleFields || containers.has(node) && frame.propertyContext;
+      const retainPath = () => {
+        budget.charge("retainedBytes", path.length * 8);
+        return path.slice();
+      };
+      if (containers.has(node)) {
+        records.push([retainPath(), node.namespace, node.localName, [...node.namespaces], [...context], node.attributes, node.content.filter((item) => item.kind !== "element")]);
+      } else if (!view.canEdit(node)) {
+        const { declaration: ignoredDeclaration, ...content } = node;
+        budget.charge("retainedBytes", 192);
+        records.push([retainPath(), [...node.namespaces], [...context], displayXml(content, budget, false)]);
+        pending.pop();
+        path.pop();
+        continue;
+      } else {
+        const attributes = node.attributes.filter((attribute) => attribute.namespace !== "http://www.w3.org/2000/xmlns/" && !view.canEdit(attribute));
+        if (attributes.length) records.push([retainPath(), [...node.namespaces], [...context], attributes]);
+      }
+      frame.index = 0;
+    }
+    const child = node.children[frame.index++];
+    if (!child) {
+      pending.pop();
+      path.pop();
+      continue;
+    }
+    let slot;
+    if (frame.namedProperties || nativeProperties(child)) {
+      const name = JSON.stringify([child.namespace, child.localName]);
+      const ordinal = frame.ordinals.get(name) ?? 0;
+      frame.ordinals.set(name, ordinal + 1);
+      budget.charge("work", name.length);
+      budget.charge("retainedBytes", name.length * 4 + 48);
+      slot = name + ":" + ordinal;
+    } else slot = frame.contentIndex++;
+    budget.charge("retainedBytes", 136);
+    path.push(slot);
+    pending.push({ node: child, inherited: frame.context, propertyContext: frame.namedProperties, ordinals: /* @__PURE__ */ new Map(), contentIndex: 0, index: -1 });
+  }
+  return JSON.stringify(records);
+}
+
+// packages/safe-bash-docx-engine/src/stored-measure.ts
+function storedMeasure(raw, unit = "twip", message = "Invalid stored document measure.") {
+  const text = trimXmlWhitespace(raw), multiplier = { in: 914400, cm: 36e4, mm: 36e3, pt: 12700, pc: 152400, pi: 152400 }[text.slice(-2)];
+  const physical = multiplier !== void 0, scalar = physical ? text.slice(0, -2) : text;
+  let start = scalar[0] === "-" || !physical && scalar[0] === "+" ? 1 : 0;
+  if (start === scalar.length || physical && unit !== "twip" && scalar[0] === "-") throw new InvalidDocumentError(message);
+  let digits = 0, decimal = false;
+  for (; start < scalar.length; start++) {
+    const character = scalar[start];
+    if (character >= "0" && character <= "9") {
+      digits++;
+      continue;
+    }
+    if (physical && character === "." && !decimal && digits > 0 && start < scalar.length - 1) {
+      decimal = true;
+      continue;
+    }
+    throw new InvalidDocumentError(message);
+  }
+  const value = Number(scalar);
+  if (!digits || !Number.isFinite(value) || !physical && !Number.isSafeInteger(value) || unit !== "twip" && value < 0) throw new InvalidDocumentError(message);
+  try {
+    return physical ? Length(value * multiplier) : unit === "half-point" ? Pt(value / 2) : Twips(value);
+  } catch (error) {
+    if (error instanceof RangeError || error instanceof TypeError) throw new InvalidDocumentError(message);
+    throw error;
+  }
+}
+
+// packages/safe-bash-docx-engine/src/run-properties.ts
+var underline = { NONE: "none", SINGLE: "single", WORDS: "words", DOUBLE: "double", DOTTED: "dotted", THICK: "thick", DASH: "dash", DOT_DASH: "dotDash", DOT_DOT_DASH: "dotDotDash", WAVY: "wave", DOTTED_HEAVY: "dottedHeavy", DASH_HEAVY: "dashedHeavy", DOT_DASH_HEAVY: "dashDotHeavy", DOT_DOT_DASH_HEAVY: "dashDotDotHeavy", WAVY_HEAVY: "wavyHeavy", DASH_LONG: "dashLong", WAVY_DOUBLE: "wavyDouble", DASH_LONG_HEAVY: "dashLongHeavy" };
+var highlights = { AUTO: "default", BLACK: "black", BLUE: "blue", BRIGHT_GREEN: "green", DARK_BLUE: "darkBlue", DARK_RED: "darkRed", DARK_YELLOW: "darkYellow", GRAY_25: "lightGray", GRAY_50: "darkGray", GREEN: "darkGreen", PINK: "magenta", RED: "red", TEAL: "darkCyan", TURQUOISE: "cyan", VIOLET: "darkMagenta", WHITE: "white", YELLOW: "yellow" };
+var themes = { ACCENT_1: "accent1", ACCENT_2: "accent2", ACCENT_3: "accent3", ACCENT_4: "accent4", ACCENT_5: "accent5", ACCENT_6: "accent6", BACKGROUND_1: "background1", BACKGROUND_2: "background2", DARK_1: "dark1", DARK_2: "dark2", FOLLOWED_HYPERLINK: "followedHyperlink", HYPERLINK: "hyperlink", LIGHT_1: "light1", LIGHT_2: "light2", TEXT_1: "text1", TEXT_2: "text2" };
+var order = "rStyle rFonts b bCs i iCs caps smallCaps strike dstrike outline shadow emboss imprint noProof snapToGrid vanish webHidden color spacing w kern position sz szCs highlight u effect bdr shd fitText vertAlign rtl cs em lang eastAsianLayout specVanish oMath rPrChange".split(" ");
+var toggles = new Set("b bCs i iCs caps smallCaps strike dstrike outline shadow emboss imprint noProof snapToGrid vanish webHidden rtl cs specVanish oMath".split(" "));
+var xmlns = "http://www.w3.org/2000/xmlns/";
+function runElementOpen(node) {
+  return `<${node.name}${[...node.namespaces].filter(([prefix]) => prefix !== "xml").map(([prefix, uri]) => ` ${prefix ? "xmlns:" + prefix : "xmlns"}="${xmlValue(uri)}"`).join("")}${node.attributes.filter((a) => a.namespace !== xmlns).map((a) => ` ${a.name}="${xmlValue(a.value)}"`).join("")}>`;
+}
+function formattedRunProperties(editor, run, options, children = (node) => node.children, metadata = {}) {
+  for (const value of [
+    options.font,
+    options.ascii,
+    options.highAnsi,
+    options.eastAsia,
+    options.complexScript,
+    metadata.ascii,
+    metadata.highAnsi,
+    metadata.eastAsia,
+    metadata.complexScript
+  ]) {
+    if (value !== void 0 && value !== null && !validFontName(value))
+      throw new InvalidValueError("Font references must be nonempty names without control characters.");
+  }
+  const w = run.namespace;
+  const containers = children(run).filter((c) => c.namespace === w && c.localName === "rPr");
+  if (containers.length > 1) throw new UnsupportedEditError("Duplicate run property containers cannot be edited.");
+  const props = containers[0];
+  const patches = /* @__PURE__ */ new Map();
+  const added = [];
+  const property = (name, attrs) => {
+    const matches = props ? children(props).filter((c) => c.namespace === w && c.localName === name) : [];
+    if (matches.length > 1) throw new UnsupportedEditError("Duplicate direct properties cannot be edited.");
+    const node = matches[0];
+    if (attrs === null) {
+      if (node) patches.set(node, "");
+      return;
+    }
+    const old = new Map(node?.attributes.filter((a) => a.namespace === w).map((a) => [a.localName, a.value]));
+    if (node && Object.entries(attrs).every(([key, value]) => {
+      const existing = old.get(key);
+      if (value === null) return existing === void 0;
+      if (key === "val" && toggles.has(name)) return storedBooleanValue(existing ?? "1") === (value === "1");
+      if (key === "val" && name === "sz") return existing !== void 0 && Number(existing) === Number(value);
+      return existing === value;
+    })) return;
+    const prefix = node?.name.includes(":") ? node.name.split(":")[0] : [...node?.namespaces ?? run.namespaces].find(([prefix2, uri]) => prefix2 && uri === w)?.[0] ?? "fmt";
+    const qualified = node?.name ?? `${prefix}:${name}`;
+    const retained = node?.attributes.filter((a) => a.namespace !== xmlns && !(a.namespace === w && Object.hasOwn(attrs, a.localName))).map((a) => ` ${a.name}="${xmlValue(a.value)}"`).join("") ?? "";
+    const bindings = new Map(node?.namespaces ?? run.namespaces);
+    bindings.set(prefix, w);
+    const declarations = [...bindings].filter(([p]) => p !== "xml").map(([p, uri]) => ` ${p ? "xmlns:" + p : "xmlns"}="${xmlValue(uri)}"`).join("");
+    const values = Object.entries(attrs).filter(([, value]) => value !== null).map(([key, value]) => ` ${prefix}:${key}="${xmlValue(value)}"`).join("");
+    const content2 = node ? editor.sourceXml(node, /* @__PURE__ */ new Map(), true) : "";
+    const xml2 = !retained && !values && !content2 ? "" : `<${qualified}${declarations}${retained}${values}${content2 ? ">" + content2 + `</${qualified}>` : "/>"}`;
+    if (node) patches.set(node, xml2);
+    else if (xml2) added.push({ name, xml: xml2 });
+  };
+  for (const [key, name] of [["bold", "b"], ["italic", "i"], ["strike", "strike"], ["hidden", "vanish"], ["rtl", "rtl"], ["allCaps", "caps"], ["complexScriptEnabled", "cs"], ["csBold", "bCs"], ["csItalic", "iCs"], ["doubleStrike", "dstrike"], ["emboss", "emboss"], ["imprint", "imprint"], ["math", "oMath"], ["noProof", "noProof"], ["outline", "outline"], ["shadow", "shadow"], ["smallCaps", "smallCaps"], ["snapToGrid", "snapToGrid"], ["specVanish", "specVanish"], ["webHidden", "webHidden"]]) {
+    const value = options[key];
+    if (value !== void 0) property(name, value === null ? null : { val: String(Number(value)) });
+  }
+  if (options.underline !== void 0) property("u", options.underline === null ? null : { val: typeof options.underline === "boolean" ? options.underline ? "single" : "none" : underline[options.underline.name] });
+  if (options.highlight !== void 0) property("highlight", options.highlight === null ? null : { val: highlights[options.highlight.name] });
+  if (options.size !== void 0) {
+    const units = { emu: 1, in: 914400, cm: 36e4, mm: 36e3, pt: 12700 };
+    property("sz", options.size === null ? null : { val: String(Math.round(Math.round(options.size.value * units[options.size.unit]) / 6350)) });
+  }
+  const fonts = {};
+  if (options.font !== void 0) Object.assign(fonts, { ascii: options.font, hAnsi: options.font });
+  for (const [key, attr] of [["ascii", "ascii"], ["highAnsi", "hAnsi"], ["eastAsia", "eastAsia"], ["complexScript", "cs"], ["asciiTheme", "asciiTheme"], ["highAnsiTheme", "hAnsiTheme"], ["eastAsiaTheme", "eastAsiaTheme"], ["complexScriptTheme", "cstheme"]])
+    if (options[key] !== void 0) fonts[attr] = options[key];
+  for (const [key, attr] of [["ascii", "ascii"], ["highAnsi", "hAnsi"], ["eastAsia", "eastAsia"], ["complexScript", "cs"]]) {
+    if (metadata[key] !== void 0) fonts[attr] = metadata[key];
+    if (metadata.theme === null) fonts[attr === "cs" ? "cstheme" : attr + "Theme"] = null;
+    else if (metadata.theme?.[key] !== void 0) fonts[attr === "cs" ? "cstheme" : attr + "Theme"] = metadata.theme[key];
+  }
+  if (Object.keys(fonts).length) property("rFonts", fonts);
+  const language = {};
+  if (options.language !== void 0) language.val = options.language;
+  for (const [key, attr] of [["latin", "val"], ["eastAsia", "eastAsia"], ["bidi", "bidi"]]) {
+    if (metadata.language === null) language[attr] = null;
+    else if (metadata.language?.[key] !== void 0) language[attr] = metadata.language[key];
+  }
+  if (Object.keys(language).length) property("lang", language);
+  if (options.color !== void 0 && options.themeColor === void 0) property("color", options.color === null ? null : { val: options.color.toUpperCase(), themeColor: null, themeTint: null, themeShade: null });
+  if (options.themeColor !== void 0) {
+    const color = props && children(props).find((c) => c.namespace === w && c.localName === "color");
+    property("color", options.themeColor === null ? { themeColor: null, themeTint: null, themeShade: null } : {
+      ...color?.attributes.some((a) => a.namespace === w && a.localName === "val") ? {} : { val: options.color ?? "auto" },
+      themeColor: themes[options.themeColor.name]
+    });
+  }
+  const baseline = options.baseline !== void 0 ? options.baseline : options.superscript === true ? "superscript" : options.subscript === true ? "subscript" : options.superscript === false || options.subscript === false ? "baseline" : options.superscript === null || options.subscript === null ? null : void 0;
+  if (baseline !== void 0) property("vertAlign", baseline === null ? null : { val: baseline });
+  if (!patches.size && !added.length) return props ? editor.sourceXml(props) : "";
+  let tail = "";
+  const insertions = /* @__PURE__ */ new Map();
+  for (const addition of added.sort((a, b) => order.indexOf(a.name) - order.indexOf(b.name))) {
+    const next = props && children(props).find((child) => child.namespace === w && order.indexOf(child.localName) > order.indexOf(addition.name));
+    if (next) insertions.set(next, (insertions.get(next) ?? "") + addition.xml);
+    else tail += addition.xml;
+  }
+  for (const [node, markup] of insertions) patches.set(node, markup + (patches.get(node) ?? editor.sourceXml(node)));
+  const content = (props ? editor.sourceXml(props, patches, true) : "") + tail;
+  if (!content && (!props || props.attributes.every((a) => a.namespace === xmlns))) return "";
+  return props ? runElementOpen(props) + content + `</${props.name}>` : `<fmt:rPr xmlns:fmt="${xmlValue(w)}">${content}</fmt:rPr>`;
+}
+function equivalentRunKey(run) {
+  const w = run.namespace;
+  if (run.content.some((c) => c.kind !== "element") || run.children.some((c) => c.namespace !== w || !["rPr", "t", "tab", "br", "cr", "noBreakHyphen", "softHyphen"].includes(c.localName))) return void 0;
+  if (run.children.some((c) => c.localName !== "rPr" && c.content.some((child) => child.kind !== "text"))) return void 0;
+  const props = run.children.filter((c) => c.localName === "rPr");
+  if (props.length > 1 || props.some((p) => p.content.some((c) => c.kind !== "element") || p.children.some((c) => c.namespace !== w || c.content.length || !order.includes(c.localName)))) return void 0;
+  const attributes = (node, toggle = false) => {
+    const attrs = node.attributes.filter((a) => a.namespace !== xmlns).map((a) => [a.namespace, a.localName, toggle && a.namespace === w && a.localName === "val" ? storedBooleanValue(a.value) === false ? "0" : storedBooleanValue(a.value) === true ? "1" : a.value : a.value]);
+    if (toggle && !attrs.some((a) => a[0] === w && a[1] === "val")) attrs.push([w, "val", "1"]);
+    return attrs.sort((a, b) => JSON.stringify(a).localeCompare(JSON.stringify(b)));
+  };
+  const children = props[0]?.children ?? [];
+  if (new Set(children.map((c) => c.localName)).size !== children.length) return void 0;
+  return JSON.stringify([attributes(run), props[0] ? attributes(props[0]) : [], children.map((c) => [c.localName, attributes(c, toggles.has(c.localName))]).sort((a, b) => String(a[0]).localeCompare(String(b[0])))]);
+}
+
+// packages/safe-bash-docx-engine/src/paragraph-properties.ts
+function paragraphUnits(value, divisor = 635) {
+  const emu = value.value * { emu: 1, in: 914400, cm: 36e4, mm: 36e3, pt: 12700, twip: 635 }[value.unit];
+  const rounded = Math.sign(emu) * Math.round(Math.abs(emu));
+  const result = Math.sign(rounded) * Math.round(Math.abs(rounded) / divisor);
+  if (!Number.isSafeInteger(rounded) || !Number.isSafeInteger(result))
+    throw new DocxUsageError("Paragraph length exceeds safe integer storage.");
+  return result;
+}
+var order2 = "pStyle keepNext keepLines pageBreakBefore framePr widowControl numPr suppressLineNumbers pBdr shd tabs suppressAutoHyphens kinsoku wordWrap overflowPunct topLinePunct autoSpaceDE autoSpaceDN bidi adjustRightInd snapToGrid spacing ind contextualSpacing mirrorIndents suppressOverlap jc textDirection textAlignment textboxTightWrap outlineLvl divId cnfStyle rPr sectPr pPrChange".split(" ");
+var alignments = { LEFT: "left", CENTER: "center", RIGHT: "right", JUSTIFY: "both", DISTRIBUTE: "distribute", JUSTIFY_MED: "mediumKashida", JUSTIFY_HI: "highKashida", JUSTIFY_LOW: "lowKashida", THAI_JUSTIFY: "thaiDistribute" };
+var tabAlignments = { LEFT: "left", CENTER: "center", RIGHT: "right", DECIMAL: "decimal", BAR: "bar", LIST: "list", CLEAR: "clear", END: "end", NUM: "num", START: "start" };
+function tabAlignmentXml(namespace, name) {
+  const strict = namespace === documentDialects.strict.w;
+  if (strict && name === "LIST") throw new UnsupportedEditError("The deprecated list tab alignment is unavailable in Strict documents.");
+  const value = tabAlignments[name];
+  return strict ? { left: "start", right: "end" }[value] ?? value : value;
+}
+var leaders = { SPACES: "none", DOTS: "dot", DASHES: "hyphen", LINES: "underscore", HEAVY: "heavy", MIDDLE_DOT: "middleDot" };
+var paragraphLineMultiples = { SINGLE: 1, ONE_POINT_FIVE: 1.5, DOUBLE: 2 };
+function newTabStopXml(namespace, tab, spacesLeader = "none") {
+  const leader = !tab.leader || tab.leader.name === "SPACES" ? spacesLeader : leaders[tab.leader.name];
+  return `<pf:tab xmlns:pf="${xmlValue(namespace)}" pf:pos="${paragraphUnits(tab.position)}" pf:val="${tabAlignmentXml(namespace, tab.alignment?.name ?? "LEFT")}"${leader === null ? "" : ` pf:leader="${leader}"`}></pf:tab>`;
+}
+function paragraphProperties(xml2, paragraph, options, styleId, children = (node) => node.children, spacesLeader = "none") {
+  for (const value of [options.spaceBefore, options.spaceAfter, typeof options.lineSpacing === "object" ? options.lineSpacing : void 0]) {
+    if (value != null && value.value < 0) throw new DocxUsageError("Paragraph spacing cannot be negative.");
+  }
+  if (typeof options.lineSpacing === "number") {
+    const line = Math.round(options.lineSpacing * 240);
+    if (line < 1 || !Number.isSafeInteger(line)) throw new DocxUsageError("Line spacing multiples must round to positive safe integer storage.");
+  }
+  const w = paragraph.namespace;
+  const strict = w === documentDialects.strict.w;
+  const directional = (value) => strict ? { left: "start", right: "end" }[value] ?? value : value;
+  const containers = children(paragraph).filter((c) => c.namespace === w && c.localName === "pPr");
+  if (containers.length > 1) throw new UnsupportedEditError("Duplicate paragraph property containers cannot be edited.");
+  const props = containers[0];
+  const patches = /* @__PURE__ */ new Map();
+  const added = /* @__PURE__ */ new Map();
+  const mergeOrdered = (parent, replacements, additions, names) => {
+    const prefixes = /* @__PURE__ */ new Map();
+    let tail = "";
+    for (const name of names) {
+      const markup = additions.get(name);
+      if (markup === void 0) continue;
+      const next = parent && children(parent).find((c) => c.namespace === w && names.indexOf(c.localName) > names.indexOf(name));
+      if (next) prefixes.set(next, (prefixes.get(next) ?? "") + markup);
+      else tail += markup;
+    }
+    for (const [node, prefix] of prefixes) replacements.set(node, prefix + (replacements.get(node) ?? xml2.sourceXml(node)));
+    return (parent ? xml2.sourceXml(parent, replacements, true) : "") + tail;
+  };
+  const find = (name, parent = props) => {
+    const matches = parent ? children(parent).filter((c) => c.namespace === w && c.localName === name) : [];
+    if (matches.length > 1) throw new UnsupportedEditError("Duplicate paragraph properties cannot be edited.");
+    return matches[0];
+  };
+  const element = (name, attrs, node, content2) => {
+    const prefix = node?.name.includes(":") ? node.name.split(":")[0] : [...node?.namespaces ?? paragraph.namespaces].find(([prefix2, uri]) => prefix2 && uri === w)?.[0] ?? "pf";
+    const qualified = node?.name ?? `${prefix}:${name}`;
+    const retained = node?.attributes.filter((a) => a.namespace !== "http://www.w3.org/2000/xmlns/" && !(a.namespace === w && Object.hasOwn(attrs, a.localName))) ?? [];
+    const attributes = [...retained.map((a) => ` ${a.name}="${xmlValue(a.value)}"`), ...Object.entries(attrs).filter(([, v]) => v !== null).map(([k, v]) => ` ${prefix}:${k}="${xmlValue(v)}"`)].join("");
+    const namespaces = new Map(node?.namespaces);
+    namespaces.set(prefix, w);
+    const bindings = [...namespaces].filter(([p]) => p !== "xml").map(([p, uri]) => ` ${p ? "xmlns:" + p : "xmlns"}="${xmlValue(uri)}"`).join("");
+    const inner = content2 ?? (node ? xml2.sourceXml(node, /* @__PURE__ */ new Map(), true) : "");
+    return `<${qualified}${bindings}${attributes}>${inner}</${qualified}>`;
+  };
+  const set = (name, attrs, content2) => {
+    const node = find(name);
+    if (attrs === null) {
+      if (node) patches.set(node, "");
+      return;
+    }
+    if (!node && !content2 && Object.values(attrs).every((value) => value === null)) return;
+    if (node && content2 === void 0 && Object.entries(attrs).every(([key, value]) => {
+      const old = node.attributes.find((a) => a.namespace === w && a.localName === key)?.value;
+      if (["keepNext", "keepLines", "widowControl", "pageBreakBefore"].includes(name) && key === "val")
+        return (value === "1" || value === "0") && storedBooleanValue(old ?? "1") === (value === "1");
+      return value === null ? old === void 0 : old === value;
+    })) return;
+    const markup = element(name, attrs, node, content2);
+    if (node) patches.set(node, markup);
+    else added.set(name, markup);
+  };
+  if (styleId !== void 0) set("pStyle", { val: styleId });
+  if (options.alignment !== void 0) set("jc", options.alignment === null ? null : { val: directional(alignments[options.alignment.name]) });
+  for (const [key, name] of [["keepWithNext", "keepNext"], ["keepTogether", "keepLines"], ["widowControl", "widowControl"], ["pageBreakBefore", "pageBreakBefore"]]) {
+    const value = options[key];
+    if (value !== void 0) set(name, value === null ? null : { val: String(Number(value)) });
+  }
+  if (options.outlineLevel !== void 0) set("outlineLvl", options.outlineLevel === null ? null : { val: String(options.outlineLevel) });
+  const indentation = {};
+  for (const [key, name, alternate] of [["leftIndent", "left", "start"], ["rightIndent", "right", "end"]]) {
+    const value = options[key];
+    if (value !== void 0) Object.assign(indentation, { [strict ? alternate : name]: value === null ? null : String(paragraphUnits(value)), [name + "Chars"]: null, [strict ? name : alternate]: null, [alternate + "Chars"]: null });
+  }
+  if (options.firstLineIndent !== void 0) {
+    const n = options.firstLineIndent === null ? null : paragraphUnits(options.firstLineIndent);
+    Object.assign(indentation, { firstLine: n !== null && n >= 0 ? String(n) : null, hanging: n !== null && n < 0 ? String(-n) : null, firstLineChars: null, hangingChars: null });
+  }
+  if (Object.keys(indentation).length) set("ind", indentation);
+  const spacing = {};
+  for (const [key, name] of [["spaceBefore", "before"], ["spaceAfter", "after"]]) {
+    const value = options[key];
+    if (value !== void 0) Object.assign(spacing, { [name]: value === null ? null : String(paragraphUnits(value)), [name + "Lines"]: null, [name + "Autospacing"]: null });
+  }
+  if (options.lineSpacing !== void 0) {
+    const value = options.lineSpacing;
+    Object.assign(spacing, { line: value === null ? null : String(typeof value === "number" ? Math.round(value * 240) : paragraphUnits(value)), lineRule: value === null ? null : typeof value === "number" ? "auto" : "exact" });
+  }
+  if (options.lineSpacingRule !== void 0) {
+    const rule = options.lineSpacingRule?.name;
+    if (rule === void 0) spacing.lineRule = null;
+    else {
+      spacing.lineRule = rule === "EXACTLY" ? "exact" : rule === "AT_LEAST" ? "atLeast" : "auto";
+      const fixed = paragraphLineMultiples[rule];
+      if (fixed !== void 0) spacing.line = String(fixed * 240);
+    }
+  }
+  if (Object.keys(spacing).length) set("spacing", spacing);
+  if (options.tabStops !== void 0) set("tabs", options.tabStops === null || options.tabStops.length === 0 ? null : {}, options.tabStops?.slice().sort((a, b) => paragraphUnits(a.position) - paragraphUnits(b.position)).map((tab) => element("tab", { pos: String(paragraphUnits(tab.position)), val: tabAlignmentXml(w, tab.alignment?.name ?? "LEFT"), leader: !tab.leader || tab.leader.name === "SPACES" ? spacesLeader : leaders[tab.leader.name] })).join(""));
+  if (options.tabStopsClear === true) {
+    const container = find("tabs");
+    if (container) {
+      const stops = children(container).filter((c) => c.namespace === w && c.localName === "tab");
+      if (container.attributes.every((a) => a.namespace === "http://www.w3.org/2000/xmlns/") && container.content.every((c) => c.kind === "element" && stops.includes(c))) set("tabs", null);
+      else {
+        const removals = new Map(stops.map((stop) => [stop, ""]));
+        patches.set(container, runElementOpen(container) + xml2.sourceXml(container, removals, true) + `</${container.name}>`);
+      }
+    }
+  }
+  if (options.tabStopAdd !== void 0 || options.tabStopDelete !== void 0) {
+    const container = find("tabs");
+    const stops = container ? children(container).filter((c) => c.namespace === w && c.localName === "tab") : [];
+    const changes = /* @__PURE__ */ new Map();
+    let tail = "";
+    if (options.tabStopDelete !== void 0) {
+      const index = options.tabStopDelete < 0 ? stops.length + options.tabStopDelete : options.tabStopDelete;
+      const stop = stops[index];
+      if (!stop) throw new UnsupportedEditError("Tab stop index is out of range.");
+      changes.set(stop, "");
+    } else {
+      const tab = options.tabStopAdd;
+      const position = paragraphUnits(tab.position);
+      const markup = newTabStopXml(w, tab, spacesLeader);
+      const positions = stops.map((stop) => {
+        const stored = stop.attributes.find((a) => a.namespace === w && a.localName === "pos")?.value;
+        if (stored === void 0) throw new UnsupportedEditError("Malformed tab stop positions cannot be edited.");
+        try {
+          return storedMeasure(stored).emu / 635;
+        } catch (error) {
+          if (error instanceof InvalidDocumentError) throw new UnsupportedEditError("Malformed tab stop positions cannot be edited.");
+          throw error;
+        }
+      });
+      const next = stops.find((_, index) => positions[index] > position);
+      if (next) changes.set(next, markup + xml2.sourceXml(next));
+      else tail = markup;
+    }
+    const content2 = (container ? xml2.sourceXml(container, changes, true) : "") + tail;
+    if (options.tabStopDelete !== void 0 && stops.length === 1 && container?.content.every((c) => c.kind === "element" && c.namespace === w && c.localName === "tab")) set("tabs", null);
+    else if (container) patches.set(container, runElementOpen(container) + content2 + `</${container.name}>`);
+    else set("tabs", {}, content2);
+  }
+  if (options.shading !== void 0) set("shd", options.shading === null ? null : { fill: options.shading.fill.toUpperCase(), color: options.shading.color?.toUpperCase() ?? "000000", val: options.shading.pattern, themeFill: null, themeFillTint: null, themeFillShade: null, themeColor: null, themeTint: null, themeShade: null });
+  if (options.borders !== void 0) {
+    if (options.borders === null) set("pBdr", null);
+    else if (Object.keys(options.borders).length) {
+      const container = find("pBdr"), replacements = /* @__PURE__ */ new Map();
+      const additions = /* @__PURE__ */ new Map();
+      for (const name of ["top", "left", "bottom", "right", "between"]) {
+        const border = options.borders[name];
+        if (!border) continue;
+        const node = find(name, container);
+        const markup = element(name, { val: border.style, sz: String(paragraphUnits(border.width, 12700 / 8)), color: border.color.toUpperCase(), ...border.space === void 0 ? node ? {} : { space: "0" } : { space: String(paragraphUnits(border.space, 12700)) }, themeColor: null, themeTint: null, themeShade: null }, node);
+        if (node) replacements.set(node, markup);
+        else additions.set(name, markup);
+      }
+      set("pBdr", {}, mergeOrdered(container, replacements, additions, ["top", "left", "bottom", "right", "between", "bar"]));
+    }
+  }
+  if (!patches.size && !added.size) return props ? xml2.sourceXml(props) : "";
+  const content = mergeOrdered(props, patches, added, order2);
+  return props ? runElementOpen(props) + content + `</${props.name}>` : `<pf:pPr xmlns:pf="${w}">${content}</pf:pPr>`;
+}
+
+// packages/safe-bash-docx-engine/src/table-content.ts
+function tableBorders(borders, tag, w) {
+  if (!borders) return "";
+  const edges = ["top", "left", "bottom", "right", "insideH", "insideV"];
+  return `<w:${tag}>${edges.map((edge) => {
+    const border = borders[edge];
+    if (!border) return "";
+    const size = paragraphUnits(border.width, 12700 / 8), space = border.space ? paragraphUnits(border.space, 12700) : 0;
+    if (border.width.value < 0 || size < (border.style === "none" ? 0 : 2) || size > 96 || (border.space?.value ?? 0) < 0 || space > 31)
+      throw new InvalidValueError("Table border width or spacing is outside the supported range.");
+    const name = w === documentDialects.strict.w ? { left: "start", right: "end" }[edge] ?? edge : edge;
+    return `<w:${name} w:val="${border.style}" w:sz="${size}" w:color="${border.color.toUpperCase()}" w:space="${space}"/>`;
+  }).join("")}</w:${tag}>`;
+}
+function tableShading(shading) {
+  return shading ? `<w:shd w:val="${shading.pattern}" w:color="${shading.color?.toUpperCase() ?? "auto"}" w:fill="${shading.fill.toUpperCase()}"/>` : "";
+}
+function tableMargins(margins, tag, w) {
+  if (!margins) return "";
+  return `<w:${tag}>${["top", "left", "bottom", "right"].map((edge) => {
+    const value = margins[edge];
+    if (!value) return "";
+    const name = w === documentDialects.strict.w ? { left: "start", right: "end" }[edge] ?? edge : edge;
+    return `<w:${name} w:w="${twips(value, false)}" w:type="dxa"/>`;
+  }).join("")}</w:${tag}>`;
+}
+function tableGeometry(table, available, w) {
+  const columns = table.rows[0].length;
+  const supplied = table.columnWidths?.map((v) => twips(v));
+  if (supplied && supplied.length !== columns) throw new InvalidValueError("Column widths must match the grid column count.");
+  const sum = supplied?.reduce((total, width2) => total + width2, 0);
+  const width = table.width ? twips(table.width) : sum ?? available;
+  if (width < columns || width > available || !Number.isSafeInteger(width) || sum !== void 0 && width !== sum)
+    throw new InvalidValueError("Table grid widths must sum to a positive width within the container.");
+  const widths = supplied ?? Array.from({ length: columns }, (_, i) => Math.floor(width / columns) + (i < width % columns ? 1 : 0));
+  if (table.repeatHeader !== void 0 && table.headerRows !== void 0) throw new InvalidValueError("Choose repeatHeader or headerRows.");
+  const headers = table.headerRows ?? (table.repeatHeader ? 1 : 0);
+  if (headers > table.rows.length || table.rowOptions && table.rowOptions.length !== table.rows.length)
+    throw new InvalidValueError("Row options and header count must fit the table rows.");
+  let endedHeaders = false;
+  const rows = table.rows.map((_, index) => {
+    const options = { ...table.allowRowSplit === void 0 ? {} : { allowRowSplit: table.allowRowSplit }, ...table.rowHeight ? { height: table.rowHeight } : {}, ...table.heightRule ? { heightRule: table.heightRule } : {}, repeatHeader: index < headers, ...table.rowOptions?.[index] };
+    if (options.repeatHeader && endedHeaders) throw new InvalidValueError("Repeated headers must be consecutive leading rows.");
+    if (!options.repeatHeader) endedHeaders = true;
+    if (!options.height && options.heightRule && options.heightRule.name !== "AUTO") throw new InvalidValueError("A fixed or minimum row height requires a height.");
+    const height = options.height ? twips(options.height, false) : 0;
+    const rule = { AUTO: "auto", AT_LEAST: "atLeast", EXACTLY: "exact" }[options.heightRule?.name ?? "AT_LEAST"];
+    return `<w:trPr>${options.allowRowSplit === void 0 ? "" : `<w:cantSplit w:val="${Number(!options.allowRowSplit)}"/>`}${options.height || options.heightRule ? `<w:trHeight w:val="${height}" w:hRule="${rule}"/>` : ""}${options.repeatHeader ? '<w:tblHeader w:val="1"/>' : ""}</w:trPr>`;
+  });
+  const margins = table.cellMargin ? { top: table.cellMargin, left: table.cellMargin, bottom: table.cellMargin, right: table.cellMargin } : void 0;
+  const properties = `<w:tblW w:w="${width}" w:type="dxa"/>` + tableBorders(table.borders, "tblBorders", w) + tableShading(table.shading) + `<w:tblLayout w:type="${table.autofit === false ? "fixed" : "autofit"}"/>` + tableMargins(margins, "tblCellMar", w);
+  return { widths, rows, properties, margin: table.cellMargin ? twips(table.cellMargin, false) : 0 };
+}
+
+// packages/safe-bash-docx-engine/src/style-properties.ts
+function styleChild(node, name, children = (node2) => node2.children) {
+  return node && children(node).find((c) => c.namespace === node.namespace && c.localName === name);
+}
+function styleAttribute(node, name) {
+  return node?.attributes.find((a) => a.namespace === node.namespace && a.localName === name)?.value;
+}
+function styleIds(root, budget) {
+  const ids = /* @__PURE__ */ new Set(), stack = [root];
+  while (stack.length) {
+    const node = stack.pop();
+    budget.charge("work", 1 + node.children.length);
+    if (node.namespace === root.namespace && node.localName === "style") {
+      const id = styleAttribute(node, "styleId");
+      if (id !== void 0) ids.add(id);
+    }
+    for (const child of node.children) stack.push(child);
+  }
+  return ids;
+}
+function styleToggle(node) {
+  if (!node) return null;
+  return storedBoolean(styleAttribute(node, "val") ?? "1", "Invalid style boolean value.");
+}
+var styleToggleFlags = ["bold", "italic", "csBold", "csItalic", "allCaps", "smallCaps", "strike", "doubleStrike", "outline", "shadow", "emboss", "imprint", "fontHidden"];
+function styleInteger(raw) {
+  if (raw === void 0) return null;
+  const text = trimXmlWhitespace(raw), digits = text[0] === "+" || text[0] === "-" ? text.slice(1) : text;
+  if (!digits.length || [...digits].some((char) => char < "0" || char > "9") || !Number.isSafeInteger(Number(text))) throw new InvalidDocumentError("Invalid integer style property.");
+  return Number(text);
+}
+function readStyleProperties(run, paragraph, children = (node) => node.children) {
+  const child = (node, name) => styleChild(node, name, children);
+  const numeric = (node, attribute = "val", divisor = 1) => {
+    const raw = styleAttribute(node, attribute);
+    if (raw === void 0) return null;
+    if (divisor !== 1) {
+      const unsigned = node?.localName === "spacing" && ["before", "after"].includes(attribute) || node?.localName === "ind" && ["firstLine", "hanging"].includes(attribute);
+      return storedMeasure(raw, divisor === 2 ? "half-point" : unsigned ? "unsigned-twip" : "twip").emu / (divisor === 2 ? 12700 : divisor * 635);
+    }
+    return styleInteger(raw) / divisor;
+  };
+  const num = child(paragraph, "numPr"), spacing = child(paragraph, "spacing"), ind = child(paragraph, "ind");
+  const tabs = child(paragraph, "tabs");
+  const lineRule = styleAttribute(spacing, "lineRule") ?? null;
+  const hanging = numeric(ind, "hanging", 20);
+  return {
+    ...Object.fromEntries(Object.entries(styleFontFlags).map(([key, tag]) => [key, styleToggle(child(run, tag))])),
+    font: styleAttribute(child(run, "rFonts"), "ascii") ?? null,
+    size: numeric(child(run, "sz"), "val", 2),
+    color: styleAttribute(child(run, "color"), "val") ?? null,
+    themeColor: styleAttribute(child(run, "color"), "themeColor") ?? null,
+    underline: styleAttribute(child(run, "u"), "val") ?? null,
+    highlight: styleAttribute(child(run, "highlight"), "val") ?? null,
+    baseline: styleAttribute(child(run, "vertAlign"), "val") ?? null,
+    language: styleAttribute(child(run, "lang"), "val") ?? null,
+    outlineLevel: numeric(child(paragraph, "outlineLvl")),
+    keepWithNext: styleToggle(child(paragraph, "keepNext")),
+    keepTogether: styleToggle(child(paragraph, "keepLines")),
+    widowControl: styleToggle(child(paragraph, "widowControl")),
+    pageBreakBefore: styleToggle(child(paragraph, "pageBreakBefore")),
+    leftIndent: numeric(ind, "start", 20) ?? numeric(ind, "left", 20),
+    rightIndent: numeric(ind, "end", 20) ?? numeric(ind, "right", 20),
+    firstLineIndent: hanging === null ? numeric(ind, "firstLine", 20) : -hanging,
+    lineSpacing: numeric(spacing, "line", lineRule === "auto" || lineRule === null ? 240 : 20),
+    lineSpacingRule: lineRule,
+    alignment: styleAttribute(child(paragraph, "jc"), "val") ?? null,
+    spaceBefore: numeric(spacing, "before", 20),
+    spaceAfter: numeric(spacing, "after", 20),
+    tabStops: tabs ? children(tabs).filter((n) => n.namespace === tabs.namespace && n.localName === "tab").map((n) => ({ position: numeric(n, "pos", 20) ?? 0, alignment: styleAttribute(n, "val") ?? "left", leader: styleAttribute(n, "leader") ?? "none" })) : null,
+    numbering: num ? { id: styleAttribute(child(num, "numId"), "val") ?? null, level: numeric(child(num, "ilvl")) } : null
+  };
+}
+function inheritStyleProperties(inherited, direct) {
+  const value = Object.fromEntries(Object.entries(direct).map(([key, item]) => [key, item === null ? inherited[key] : item]));
+  const toggles2 = Object.fromEntries(styleToggleFlags.map((key) => [key, direct[key] === null || direct[key] === false ? inherited[key] : !inherited[key]]));
+  const tabs = new Map(inherited.tabStops?.map((tab) => [tab.position, tab]));
+  for (const tab of direct.tabStops ?? []) {
+    if (tab.alignment === "clear") tabs.delete(tab.position);
+    else tabs.set(tab.position, tab);
+  }
+  return {
+    ...value,
+    ...toggles2,
+    tabStops: direct.tabStops === null ? inherited.tabStops : [...tabs.values()].sort((a, b) => a.position - b.position),
+    numbering: direct.numbering === null ? inherited.numbering : { id: direct.numbering.id ?? inherited.numbering?.id ?? null, level: direct.numbering.level ?? inherited.numbering?.level ?? null }
+  };
+}
+function mergeStyleChildren(xml2, parent, updates, order3, attributes = {}, children = (node) => node.children) {
+  const replacements = /* @__PURE__ */ new Map();
+  const prefixes = /* @__PURE__ */ new Map();
+  let tail = "";
+  for (const [name, markup] of [...updates].sort(([a], [b]) => order3.indexOf(a) - order3.indexOf(b))) {
+    const matches = children(parent).filter((c) => c.namespace === parent.namespace && c.localName === name);
+    if (matches.length > 1) throw new UnsupportedEditError("Duplicate style properties cannot be edited.");
+    if (matches[0]) {
+      replacements.set(matches[0], markup);
+      continue;
+    }
+    if (!markup) continue;
+    const next = children(parent).find((c) => c.namespace === parent.namespace && order3.indexOf(c.localName) > order3.indexOf(name));
+    if (next) prefixes.set(next, (prefixes.get(next) ?? "") + markup);
+    else tail += markup;
+  }
+  for (const [node, prefix2] of prefixes) replacements.set(node, prefix2 + (replacements.get(node) ?? xml2.sourceXml(node)));
+  const content = xml2.sourceXml(parent, replacements, true) + tail;
+  if (!Object.keys(attributes).length && !tail && !prefixes.size) return xml2.sourceXml(parent, replacements);
+  const retained = parent.attributes.filter((a) => a.namespace !== parent.namespace || !Object.hasOwn(attributes, a.localName));
+  const namespaces = new Map(parent.namespaces);
+  let prefix = [...namespaces].find(([name, namespace]) => name && namespace === parent.namespace)?.[0] ?? "st";
+  for (let n = 1; namespaces.has(prefix) && namespaces.get(prefix) !== parent.namespace; n++) prefix = `st${n}`;
+  namespaces.set(prefix, parent.namespace);
+  const open = runElementOpen({ ...parent, attributes: retained, namespaces });
+  const added = Object.entries(attributes).filter(([, v]) => v !== null).map(([key, value]) => ` ${prefix}:${key}="${xmlValue(value)}"`).join("");
+  return open.slice(0, -1) + added + ">" + content + `</${parent.name}>`;
+}
+
+// packages/safe-bash-docx-engine/src/style-names.ts
+var displayNames = ["Caption", "Header", "Footer", "Heading 1", "Heading 2", "Heading 3", "Heading 4", "Heading 5", "Heading 6", "Heading 7", "Heading 8", "Heading 9"];
+function styleDisplayName(name, builtin = true) {
+  return builtin ? displayNames.find((value) => value.toLowerCase() === name) ?? name : name;
+}
+function styleStoredName(name, builtin = true) {
+  if (builtin && /^Heading[1-9]$/.test(name)) return `heading ${name.slice(7)}`;
+  return builtin && displayNames.includes(name) ? name.toLowerCase() : name;
+}
+function selectNamedStyles(nodes, name, children, budget) {
+  const entries = nodes.map((node) => {
+    const fields = children(node), definition = fields.find((child) => child.namespace === node.namespace && child.localName === "name");
+    budget.charge("work", 1 + node.attributes.length + fields.length + (definition?.attributes.length ?? 0));
+    const stored = definition?.attributes.find((attribute) => attribute.namespace === node.namespace && attribute.localName === "val")?.value;
+    const builtin = !storedBoolean(node.attributes.find((attribute) => attribute.namespace === node.namespace && attribute.localName === "customStyle")?.value ?? "0");
+    return { node, stored, builtin, displayed: stored === void 0 ? void 0 : styleDisplayName(stored, builtin) };
+  });
+  const exact = entries.filter((entry) => entry.displayed === name);
+  return (exact.length ? exact : entries.filter((entry) => entry.builtin && entry.stored !== void 0 && styleStoredName(entry.stored) === styleStoredName(name))).map((entry) => entry.node);
+}
+
+// packages/safe-bash-docx-engine/src/create-content.ts
+function xmlValue(value) {
+  let result = "";
+  for (const char of value) {
+    const n = char.codePointAt(0);
+    if (!(n === 9 || n === 10 || n === 13 || n >= 32 && n <= 55295 || n >= 57344 && n <= 65533 || n >= 65536 && n <= 1114111))
+      throw new InvalidValueError("Invalid XML character in structured content.");
+    result += { "&": "&amp;", "<": "&lt;", ">": "&gt;", '"': "&quot;", "\r": "&#13;", "\n": "&#10;", "	": "&#9;" }[char] ?? char;
+  }
+  return result;
+}
+function lengthEmu(value, positive = true) {
+  if (value.value < 0 || positive && value.value === 0) throw new InvalidValueError("Document length must be nonnegative or positive for this setting.");
+  const scale = { emu: 1, in: 914400, cm: 36e4, mm: 36e3, pt: 12700, twip: 635 }[value.unit];
+  const emu = Math.round(value.value * scale);
+  if (!Number.isSafeInteger(emu)) throw new InvalidValueError("Document length is outside the safe integer range.");
+  return emu;
+}
+function twips(value, positive = true) {
+  const result = Math.round(lengthEmu(value, positive) / 635);
+  if (result < (positive ? 1 : 0) || result > 31680)
+    throw new InvalidValueError("Document length is outside the supported page range.");
+  return result;
+}
+function pageGeometry(page, existing, w, children = (node) => node.children) {
+  const attribute = (element, name) => {
+    const node = existing && children(existing).find((child) => child.namespace === w && child.localName === element);
+    const raw = node?.attributes.find((a) => a.namespace === w && a.localName === name)?.value;
+    return raw === void 0 ? void 0 : Number(raw);
+  };
+  const width = page?.width ? twips(page.width) : attribute("pgSz", "w") ?? 12240;
+  const height = page?.height ? twips(page.height) : attribute("pgSz", "h") ?? 15840;
+  const margins = Object.fromEntries(Object.entries({ top: 1440, right: 1440, bottom: 1440, left: 1440, header: 720, footer: 720, gutter: 0 }).map(([key, fallback]) => {
+    const value = page?.margins?.[key];
+    return [key, value ? twips(value, false) : attribute("pgMar", key) ?? fallback];
+  }));
+  if (!Number.isSafeInteger(width) || !Number.isSafeInteger(height) || Object.values(margins).some((v) => !Number.isSafeInteger(v) || v < 0) || width <= margins.left + margins.right + margins.gutter || height <= margins.top + margins.bottom)
+    throw new InvalidValueError("Page margins must leave positive content extent.");
+  const xml2 = `<w:pgSz w:w="${width}" w:h="${height}"${page?.orientation ? ` w:orient="${page.orientation}"` : ""}/><w:pgMar ${Object.entries(margins).map(([key, value]) => `w:${key}="${value}"`).join(" ")}/><w:cols w:num="1"/>`;
+  return { width: width - margins.left - margins.right - margins.gutter, xml: xml2 };
+}
+function renderContent(content, w, budget, stylesRoot, containerWidth = 9360, reservedStyleIds = /* @__PURE__ */ new Set()) {
+  const styles = /* @__PURE__ */ new Map();
+  const ids = stylesRoot ? styleIds(stylesRoot, budget) : /* @__PURE__ */ new Set();
+  for (const id of reservedStyleIds) {
+    budget.charge("work", 1);
+    ids.add(id);
+  }
+  const children = stylesRoot ? activeXmlChildren(stylesRoot, budget) : (node) => node.children;
+  for (const style of stylesRoot ? children(stylesRoot) : []) {
+    if (style.namespace !== w || style.localName !== "style") continue;
+    const attribute = (node, key) => node.attributes.find((a) => a.namespace === w && a.localName === key)?.value;
+    const id = attribute(style, "styleId"), type = attribute(style, "type") ?? "paragraph";
+    const name = children(style).find((c) => c.namespace === w && c.localName === "name");
+    const stored = name && attribute(name, "val");
+    const builtin = !storedBoolean(attribute(style, "customStyle") ?? "0");
+    const value = stored === void 0 ? void 0 : styleDisplayName(stored, builtin);
+    if (value && id && type) {
+      if (styles.has(value)) throw new InvalidValueError("Ambiguous style name in template.");
+      const properties = children(style).find((child) => child.namespace === w && child.localName === "pPr");
+      const outline = properties && children(properties).find((child) => child.namespace === w && child.localName === "outlineLvl");
+      styles.set(value, { id, type, outline: outline ? attribute(outline, "val") : void 0, builtin });
+    }
+  }
+  const added = [];
+  const builtinOverrides = /* @__PURE__ */ new Map();
+  const allocate = () => {
+    let n = 1;
+    while (ids.has(`Style${n}`)) n++;
+    const id = `Style${n}`;
+    ids.add(id);
+    return id;
+  };
+  for (const style of content.styles ?? []) {
+    const name = style.name;
+    const size = style.size === void 0 ? void 0 : Math.round(lengthEmu(style.size) / 6350);
+    if (size !== void 0 && (size < 1 || size > 3276)) throw new InvalidValueError("Font size must round to 1 through 3276 half-points.");
+    const formatting = (style.font === void 0 ? "" : `<w:rFonts w:ascii="${xmlValue(style.font)}" w:hAnsi="${xmlValue(style.font)}"/>`) + (size === void 0 ? "" : `<w:sz w:val="${size}"/>`) + (style.bold === void 0 ? "" : `<w:b w:val="${Number(style.bold)}"/>`) + (style.italic === void 0 ? "" : `<w:i w:val="${Number(style.italic)}"/>`);
+    if (styles.has(name)) {
+      const existing = styles.get(name);
+      if (!existing.builtin || existing.type !== style.type || builtinOverrides.has(existing.id) || reservedStyleIds.size > 0) {
+        throw new InvalidValueError("A declared style name already exists.");
+      }
+      builtinOverrides.set(existing.id, formatting);
+      continue;
+    }
+    const headingMatch = style.type === "paragraph" && reservedStyleIds.size === 0 ? name === "Title" ? 0 : /^Heading ?([1-9])$/.exec(name) ? Number(/^Heading ?([1-9])$/.exec(name)[1]) : void 0 : void 0;
+    if (headingMatch !== void 0) {
+      const stem = headingMatch === 0 ? "Title" : `Heading${headingMatch}`;
+      if (!ids.has(stem)) {
+        ids.add(stem);
+        const displayName = headingMatch === 0 ? "Title" : `Heading ${headingMatch}`;
+        const entry = { id: stem, type: "paragraph", builtin: true, outline: headingMatch ? String(headingMatch - 1) : void 0 };
+        styles.set(name, entry);
+        styles.set(displayName, entry);
+        styles.set(stem, entry);
+        added.push(`<w:style xmlns:w="${w}" w:type="paragraph" w:customStyle="0" w:styleId="${stem}"><w:name w:val="${xmlValue(displayName)}"/><w:qFormat/>${headingMatch ? `<w:pPr><w:outlineLvl w:val="${headingMatch - 1}"/></w:pPr>` : ""}${formatting ? `<w:rPr>${formatting}</w:rPr>` : ""}</w:style>`);
+        continue;
+      }
+    }
+    const id = allocate();
+    styles.set(name, { id, type: style.type });
+    added.push(`<w:style xmlns:w="${w}" w:type="${style.type}" w:customStyle="1" w:styleId="${id}"><w:name w:val="${xmlValue(style.name)}"/>${formatting ? `<w:rPr>${formatting}</w:rPr>` : ""}</w:style>`);
+  }
+  const resolve = (name, type) => {
+    const exact = styles.get(name), alias = styles.get(styleDisplayName(name));
+    const style = exact ?? (alias?.builtin ? alias : void 0);
+    if (!style && type === "paragraph" && reservedStyleIds.size === 0) {
+      const m = name === "Title" ? 0 : /^Heading ?([1-9])$/.exec(name) ? Number(/^Heading ?([1-9])$/.exec(name)[1]) : void 0;
+      if (m !== void 0) return heading(m);
+    }
+    if (!style || style.type !== type) throw new InvalidValueError("Expected an existing style of the selected kind.");
+    return style.id;
+  };
+  const headings = /* @__PURE__ */ new Map();
+  const heading = (level) => {
+    if (headings.has(level)) return headings.get(level);
+    const name = level === 0 ? "Title" : `Heading ${level}`;
+    const stem = level === 0 ? "Title" : `Heading${level}`;
+    const found = [...styles.entries()].find(([label2, style]) => {
+      const suffix = style.id.slice(stem.length);
+      const identity = style.id === stem || style.id.startsWith(stem) && suffix.length > 0 && [...suffix].every((c) => c >= "0" && c <= "9");
+      return identity && style.builtin && style.type === "paragraph" && (label2 === name || label2.startsWith(name + " ")) && (level === 0 || styleInteger(style.outline) === level - 1);
+    })?.[1];
+    if (found) {
+      headings.set(level, found.id);
+      return found.id;
+    }
+    let id = stem;
+    for (let n = 1; ids.has(id); n++) id = `${stem}${n}`;
+    ids.add(id);
+    let label = name;
+    for (let n = 1; styles.has(label); n++) label = `${name} ${n}`;
+    styles.set(label, { id, type: "paragraph", builtin: true, outline: level ? String(level - 1) : void 0 });
+    added.push(`<w:style xmlns:w="${w}" w:type="paragraph" w:customStyle="0" w:styleId="${id}"><w:name w:val="${label}"/><w:qFormat/>${level ? `<w:pPr><w:outlineLvl w:val="${level - 1}"/></w:pPr>` : ""}</w:style>`);
+    headings.set(level, id);
+    return id;
+  };
+  const run = (input) => {
+    let formatting = input.style === void 0 ? "" : `<w:rStyle w:val="${xmlValue(resolve(input.style, "character"))}"/>`;
+    for (const [key, tag] of [["bold", "b"], ["italic", "i"]]) if (input[key] != null) formatting += `<w:${tag} w:val="${Number(input[key])}"/>`;
+    if (input.underline != null) {
+      const values = { NONE: "none", SINGLE: "single", WORDS: "words", DOUBLE: "double", DOTTED: "dotted", THICK: "thick", DASH: "dash", DOT_DASH: "dotDash", DOT_DOT_DASH: "dotDotDash", WAVY: "wave", DOTTED_HEAVY: "dottedHeavy", DASH_HEAVY: "dashedHeavy", DOT_DASH_HEAVY: "dashDotHeavy", DOT_DOT_DASH_HEAVY: "dashDotDotHeavy", WAVY_HEAVY: "wavyHeavy", DASH_LONG: "dashLong", WAVY_DOUBLE: "wavyDouble", DASH_LONG_HEAVY: "dashLongHeavy" };
+      const value = typeof input.underline === "boolean" ? input.underline ? "single" : "none" : values[input.underline.name];
+      formatting += `<w:u w:val="${value}"/>`;
+    }
+    let text = "", pending = "";
+    const flush = () => {
+      if (pending) {
+        text += `<w:t xml:space="preserve">${xmlValue(pending)}</w:t>`;
+        pending = "";
+      }
+    };
+    for (const char of input.text) {
+      if (char === "	" || char === "\n" || char === "\r") {
+        flush();
+        text += char === "	" ? "<w:tab/>" : "<w:br/>";
+      } else pending += char;
+    }
+    flush();
+    return `<w:r>${formatting ? `<w:rPr>${formatting}</w:rPr>` : ""}${text}</w:r>`;
+  };
+  const blocks = (items, width, depth) => {
+    budget.check("xmlDepth", depth);
+    return items.map((block) => {
+      budget.charge("work", 1);
+      if (block.kind === "paragraph") {
+        const style2 = block.level !== void 0 ? heading(block.level) : block.style === void 0 ? void 0 : resolve(block.style, "paragraph");
+        const props = style2 ? `<w:pPr><w:pStyle w:val="${xmlValue(style2)}"/></w:pPr>` : "";
+        return `<w:p xmlns:w="${w}">${props}${block.runs ? block.runs.map(run).join("") : block.text === void 0 ? "" : run({ text: block.text })}</w:p>`;
+      }
+      const rows = block.rows.length, columns = block.rows[0].length;
+      budget.check("tableRows", rows);
+      budget.check("tableColumns", columns);
+      budget.charge("tableCells", rows * columns);
+      const geometry = tableGeometry(block, width, w);
+      const { widths } = geometry;
+      const style = block.style !== void 0 ? `<w:tblStyle w:val="${xmlValue(resolve(block.style, "table"))}"/>` : "";
+      return `<w:tbl xmlns:w="${w}"><w:tblPr>${style}${geometry.properties}</w:tblPr><w:tblGrid>${widths.map((value) => `<w:gridCol w:w="${value}"/>`).join("")}</w:tblGrid>${block.rows.map((row, rowIndex) => `<w:tr>${geometry.rows[rowIndex]}${row.map((cell, i) => {
+        const innerWidth = widths[i] - (cell.margins?.left ? twips(cell.margins.left, false) : geometry.margin) - (cell.margins?.right ? twips(cell.margins.right, false) : geometry.margin);
+        if (innerWidth <= 0) throw new InvalidValueError("Cell margins must leave positive content width.");
+        const properties = `<w:tcW w:w="${widths[i]}" w:type="dxa"/>` + tableBorders(cell.borders, "tcBorders", w) + tableShading(cell.shading) + tableMargins(cell.margins, "tcMar", w);
+        return `<w:tc><w:tcPr>${properties}</w:tcPr>${blocks(cell.blocks, innerWidth, depth + 3)}${cell.blocks.at(-1)?.kind !== "paragraph" ? "<w:p/>" : ""}</w:tc>`;
+      }).join("")}</w:tr>`).join("")}</w:tbl>`;
+    }).join("");
+  };
+  const body = blocks(content.blocks, containerWidth, 3);
+  budget.charge("retainedBytes", (body.length + added.join("").length) * 8);
+  return { body, styles: added.join(""), builtinOverrides };
+}
+function renderTheme(theme, a) {
+  const colors = { dark1: "000000", light1: "FFFFFF", dark2: "202020", light2: "F0F0F0", accent1: "305070", accent2: "507050", accent3: "705030", accent4: "604070", accent5: "307070", accent6: "706030", hyperlink: "0000FF", followedHyperlink: "800080", ...theme.colors };
+  const tags = { dark1: "dk1", light1: "lt1", dark2: "dk2", light2: "lt2", accent1: "accent1", accent2: "accent2", accent3: "accent3", accent4: "accent4", accent5: "accent5", accent6: "accent6", hyperlink: "hlink", followedHyperlink: "folHlink" };
+  const fill = '<a:solidFill><a:schemeClr val="phClr"/></a:solidFill>';
+  return `<a:theme xmlns:a="${a}" name="${xmlValue(theme.name)}"><a:themeElements><a:clrScheme name="${xmlValue(theme.name)}">${Object.entries(colors).map(([key, value]) => `<a:${tags[key]}><a:srgbClr val="${value.toUpperCase()}"/></a:${tags[key]}>`).join("")}</a:clrScheme><a:fontScheme name="${xmlValue(theme.name)}">${[["majorFont", theme.majorFont], ["minorFont", theme.minorFont]].map(([tag, font]) => `<a:${tag}><a:latin typeface="${xmlValue(font)}"/><a:ea typeface=""/><a:cs typeface=""/></a:${tag}>`).join("")}</a:fontScheme><a:fmtScheme name="${xmlValue(theme.name)}"><a:fillStyleLst>${fill.repeat(3)}</a:fillStyleLst><a:lnStyleLst>${`<a:ln w="6350">${fill}<a:prstDash val="solid"/></a:ln>`.repeat(3)}</a:lnStyleLst><a:effectStyleLst>${"<a:effectStyle><a:effectLst/></a:effectStyle>".repeat(3)}</a:effectStyleLst><a:bgFillStyleLst>${fill.repeat(3)}</a:bgFillStyleLst></a:fmtScheme></a:themeElements></a:theme>`;
+}
+
+// packages/safe-bash-docx-engine/src/native-property-copy.ts
+function copiedNativeProperties(markup, property, root, profile, budget, moveSection = false) {
+  if (!markup) return "";
+  const chain = [];
+  budget.charge("retainedBytes", 48);
+  const ancestry = [{ node: root, index: -1 }];
+  let found = false;
+  while (ancestry.length) {
+    const frame = ancestry.at(-1);
+    if (frame.index === -1) {
+      budget.charge("work", 1);
+      chain.push(frame.node);
+      if (frame.node === property) {
+        found = true;
+        break;
+      }
+      frame.index = 0;
+    }
+    const child = frame.node.children[frame.index++];
+    if (!child) {
+      ancestry.pop();
+      chain.pop();
+      continue;
+    }
+    budget.charge("retainedBytes", 48);
+    ancestry.push({ node: child, index: -1 });
+  }
+  if (!found) throw new TypeError("Native properties have no original owner.");
+  let source = markup;
+  const childIndexes = [];
+  for (let i = chain.length - 2; i >= 0; i--) {
+    const node = chain[i], next = chain[i + 1];
+    const siblings = node.namespace === "http://schemas.openxmlformats.org/markup-compatibility/2006" && node.localName === "AlternateContent" ? node.children.filter((child) => child.namespace === node.namespace && ["Choice", "Fallback"].includes(child.localName)) : [next];
+    childIndexes.unshift(siblings.indexOf(next));
+    source = runElementOpen(node) + siblings.map((child) => child === next ? source : runElementOpen(child) + `</${child.name}>`).join("") + `</${node.name}>`;
+  }
+  const editor = new DocumentXmlEditor(new TextEncoder().encode(source), {}, profile, budget), parsed = editor.root;
+  const view = new MarkupCompatibility(parsed, profile, budget), active = /* @__PURE__ */ new Set(), containers = new Set(view[compatibilityContainers]);
+  const collect = (content) => {
+    for (const item of content) if ("source" in item && item.disposition === "understood") {
+      active.add(item.source);
+      collect(item.content);
+    }
+  };
+  collect(view.content);
+  let parent = parsed;
+  for (const index of childIndexes) parent = parent.children[index];
+  const chunks = [];
+  const pending = [];
+  const enter = (node) => {
+    budget.charge("work", 1 + node.content.length);
+    if (moveSection && node.namespace === property.namespace && node.localName === "sectPr") {
+      chunks.push(editor.sourceXml(node));
+      return;
+    }
+    const branch = node.namespace === "http://schemas.openxmlformats.org/markup-compatibility/2006" && ["Choice", "Fallback"].includes(node.localName);
+    if (!active.has(node) && !containers.has(node)) {
+      if (!branch) return;
+      const attributes2 = node.attributes.filter((attribute) => ["http://www.w3.org/2000/xmlns/", "http://www.w3.org/XML/1998/namespace", "http://schemas.openxmlformats.org/markup-compatibility/2006"].includes(attribute.namespace) || attribute.namespace === "" && node.localName === "Choice" && attribute.localName === "Requires");
+      chunks.push(runElementOpen({ ...node, attributes: attributes2 }) + `</${node.name}>`);
+      return;
+    }
+    const attributes = node.attributes.filter((attribute) => ["http://www.w3.org/2000/xmlns/", "http://www.w3.org/XML/1998/namespace", "http://schemas.openxmlformats.org/markup-compatibility/2006"].includes(attribute.namespace) || view.canEdit(attribute) || branch && attribute.namespace === "" && node.localName === "Choice" && attribute.localName === "Requires");
+    const retainedTokens = attributes.length === node.attributes.length && node.content.every((item) => ["element", "text", "cdata"].includes(item.kind));
+    const [opening, closing] = retainedTokens ? editor[nativeElementSourceTokens](node) : [runElementOpen({ ...node, attributes }), `</${node.name}>`];
+    budget.charge("retainedBytes", 64 + (retainedTokens ? 0 : (opening.length + closing.length) * 2));
+    chunks.push(opening);
+    pending.push({ node, index: 0, closing });
+  };
+  enter(parent);
+  while (pending.length) {
+    const frame = pending.at(-1), item = frame.node.content[frame.index++];
+    budget.charge("work", 1);
+    if (!item) {
+      chunks.push(frame.closing);
+      pending.pop();
+      continue;
+    }
+    if (item.kind === "element") enter(item);
+    else if (item.kind === "text" || item.kind === "cdata") {
+      budget.charge("work", item.text.length);
+      budget.charge("retainedBytes", item.text.length * 12 + 8);
+      chunks.push(xmlValue(item.text));
+    }
+  }
+  const result = chunks.join("");
+  budget.charge("retainedBytes", result.length * 2);
+  return result;
+}
+
+// packages/safe-bash-docx-engine/src/revision-markup.ts
+function revisionInfo(node) {
+  const name = node.localName;
+  if (name === "clrChange" && (node.namespace === documentDialects.transitional.a || node.namespace === documentDialects.strict.a)) return void 0;
+  const attr = (name2) => node.attributes.find((a) => a.localName === name2 && (a.namespace === node.namespace || a.namespace === documentDialects.transitional.w || a.namespace === documentDialects.strict.w))?.value ?? null;
+  const word = node.namespace === documentDialects.transitional.w || node.namespace === documentDialects.strict.w;
+  const type = !word ? "unsupported" : name === "ins" ? "insert" : name === "del" ? "delete" : ["moveFrom", "moveTo", "moveFromRangeStart", "moveFromRangeEnd", "moveToRangeStart", "moveToRangeEnd"].includes(name) ? "move" : ["rPrChange", "pPrChange"].includes(name) ? "format" : name === "sectPrChange" ? "section" : ["tblPrChange", "tblGridChange", "trPrChange", "tcPrChange", "cellIns", "cellDel", "cellMerge"].includes(name) ? "table" : "unsupported";
+  if (type === "unsupported" && !name.endsWith("Change") && !name.startsWith("conflict") && !(name.startsWith("customXml") && (name.endsWith("RangeStart") || name.endsWith("RangeEnd"))) && !(attr("author") !== null && attr("id") !== null && name !== "comment")) return void 0;
+  const snapshot = type === "format" ? node.children.filter((n) => n.namespace === node.namespace && n.localName === name.slice(0, -6)) : [];
+  const seen = /* @__PURE__ */ new Set();
+  const supported = type === "insert" || type === "delete" || type === "move" || type === "format" && snapshot.length === 1 && node.children.length === 1 && [node, snapshot[0], ...snapshot[0].children].every((element) => {
+    for (const char of element.text) if (char !== " " && char !== "	" && char !== "\r" && char !== "\n") return false;
+    return true;
+  }) && snapshot[0].attributes.every((attribute) => attribute.namespace === "http://www.w3.org/2000/xmlns/" || attribute.namespace === "http://www.w3.org/XML/1998/namespace" && (attribute.localName === "lang" || attribute.localName === "space" && ["default", "preserve"].includes(attribute.value))) && snapshot[0].children.every((property) => {
+    const field = property.localName;
+    if (property.namespace !== node.namespace || property.children.length || seen.has(field) || !(name === "rPrChange" ? ["b", "i", "rtl", "vanish", "rStyle", "lang", "rFonts"] : ["pStyle", "bidi"]).includes(field)) return false;
+    seen.add(field);
+    const allowed = field === "lang" ? ["val", "eastAsia", "bidi"] : field === "rFonts" ? ["ascii", "hAnsi", "eastAsia", "cs", "asciiTheme", "hAnsiTheme", "eastAsiaTheme", "cstheme", "hint"] : ["val"];
+    if (property.attributes.some((attribute) => attribute.namespace !== "http://www.w3.org/2000/xmlns/" && (attribute.namespace !== node.namespace || !allowed.includes(attribute.localName)))) return false;
+    const val = property.attributes.find((attribute) => attribute.namespace === node.namespace && attribute.localName === "val")?.value;
+    if (["b", "i", "rtl", "vanish", "bidi"].includes(field)) return val === void 0 || storedBooleanValue(val) !== null;
+    return !["rStyle", "pStyle"].includes(field) || val !== void 0;
+  });
+  return { id: attr("id"), author: attr("author"), timestamp: attr("date"), markup: name, namespace: node.namespace, name: attr("name"), type, support: supported ? "supported" : "opaque" };
+}
+function containsRevision(node, budget) {
+  budget?.charge("retainedBytes", 8);
+  const pending = [node];
+  while (pending.length) {
+    const current = pending.pop();
+    budget?.charge("work", 1);
+    if (revisionInfo(current) !== void 0) return true;
+    budget?.charge("retainedBytes", current.children.length * 8);
+    for (let index = current.children.length - 1; index >= 0; index--) pending.push(current.children[index]);
+  }
+  return false;
+}
+function assertOutsideRevisionRanges(root, target, budget, branches, children = activeXmlChildren(root, budget)) {
+  const selected = new Map(branches.map((branch) => [branch.alternateContent, branch.selected]));
+  const active = /* @__PURE__ */ new Set();
+  const pending = [root];
+  while (pending.length) {
+    const node = pending.pop();
+    budget.charge("work", 1);
+    if (node === target) {
+      if (active.size) throw new UnsupportedEditError("Text removal cannot cross a review range.");
+      return;
+    }
+    const info = revisionInfo(node);
+    if (info && (info.markup.endsWith("RangeStart") || info.markup.endsWith("RangeEnd"))) {
+      const key = info.namespace + ":" + info.markup.slice(0, info.markup.lastIndexOf("Range")) + ":" + (storedIntegerIdentity(info.id ?? void 0) ?? info.id);
+      if (info.markup.endsWith("RangeStart")) active.add(key);
+      else active.delete(key);
+    }
+    if (selected.has(node)) {
+      const branch = selected.get(node);
+      if (branch) pending.push(branch);
+    } else {
+      const activeChildren = children(node);
+      for (let index = activeChildren.length - 1; index >= 0; index--) pending.push(activeChildren[index]);
+    }
+  }
+}
+function containsActiveTableHistory(node, children, budget) {
+  if (node.namespace !== documentDialects.transitional.w && node.namespace !== documentDialects.strict.w || !["tbl", "tr", "tc"].includes(node.localName)) return false;
+  const pending = children(node).filter((property) => property.namespace === node.namespace && (property.localName === node.localName + "Pr" || node.localName === "tbl" && property.localName === "tblGrid"));
+  budget.charge("retainedBytes", pending.length * 8);
+  while (pending.length) {
+    const current = pending.pop();
+    budget.charge("work", 1);
+    if (revisionInfo(current) !== void 0) return true;
+    const active = children(current);
+    budget.charge("retainedBytes", active.length * 8);
+    for (let index = active.length - 1; index >= 0; index--) pending.push(active[index]);
+  }
+  return false;
+}
+function assertFormattingHistoryEditable(root, target, children, budget) {
+  assertOutsideRevisionRanges(root, target, budget, [], children);
+  const pending = [{ node: root, blocked: false }];
+  while (pending.length) {
+    const { node, blocked } = pending.pop();
+    budget.charge("work", 1);
+    const active = children(node);
+    const history = containsActiveTableHistory(node, children, budget) || node.namespace === target.namespace && (["p", "r"].includes(node.localName) || node === target) && active.filter((property) => property.namespace === target.namespace && ["pPr", "rPr"].includes(property.localName)).some((property) => children(property).some((change) => {
+      const revision = revisionInfo(change);
+      return revision?.type === "format" && revision.support === "opaque";
+    }));
+    if (node === target) {
+      if (blocked || history) throw new UnsupportedEditError("Formatting cannot reconcile complex property history.");
+      return;
+    }
+    for (let index = active.length - 1; index >= 0; index--) pending.push({ node: active[index], blocked: blocked || history });
+  }
+  throw new UnsupportedEditError("Formatting requires an active owned element.");
+}
+function paragraphTextHistory(root, paragraphs, children, budget) {
+  budget.charge("retainedBytes", paragraphs.length * 112);
+  const targets = new Set(paragraphs), activeRanges = /* @__PURE__ */ new Set();
+  if (!targets.size) return { root, paragraphs: targets };
+  const namespace = paragraphs[0].namespace;
+  const pending = [{ node: root, blocked: false }];
+  const startWork = budget.usage.work;
+  let ordinal = 0, formatWork = 0, proofWork = 0, remaining = targets.size;
+  while (pending.length) {
+    const { node, blocked } = pending.pop();
+    budget.charge("work", 1);
+    ordinal++;
+    const target = targets.has(node), outsideWork = ordinal * 2 - 1;
+    if (target) {
+      budget.charge("work", Math.max(0, proofWork + outsideWork - (budget.usage.work - startWork)));
+      if (activeRanges.size) throw new UnsupportedEditError("Text removal cannot cross a review range.");
+    }
+    const active = children(node);
+    formatWork += 2;
+    const history = node.namespace === namespace && ["p", "r"].includes(node.localName) && active.filter((property) => property.namespace === namespace && ["pPr", "rPr"].includes(property.localName)).some((property) => {
+      formatWork++;
+      return children(property).some((change) => {
+        const revision = revisionInfo(change);
+        return revision?.type === "format" && revision.support === "opaque";
+      });
+    });
+    if (target) {
+      if (node.namespace !== namespace || node.localName !== "p") throw new UnsupportedEditError("Cell text requires native paragraph owners.");
+      proofWork += outsideWork * 2 + formatWork;
+      budget.charge("work", proofWork - (budget.usage.work - startWork));
+      if (blocked || history) throw new UnsupportedEditError("Formatting cannot reconcile complex property history.");
+      if (--remaining === 0) return { root, paragraphs: targets };
+    }
+    const info = revisionInfo(node);
+    if (info && (info.markup.endsWith("RangeStart") || info.markup.endsWith("RangeEnd"))) {
+      const key = info.namespace + ":" + info.markup.slice(0, info.markup.lastIndexOf("Range")) + ":" + info.id;
+      if (info.markup.endsWith("RangeStart")) activeRanges.add(key);
+      else activeRanges.delete(key);
+    }
+    for (let index = active.length - 1; index >= 0; index--) pending.push({ node: active[index], blocked: blocked || history });
+  }
+  throw new UnsupportedEditError("Formatting requires an active owned element.");
+}
+
+// packages/safe-bash-docx-engine/src/shape-carriers.ts
+var officeShape = "http://schemas.microsoft.com/office/word/2010/wordprocessingShape";
+var officeGroup = "http://schemas.microsoft.com/office/word/2010/wordprocessingGroup";
+var vml = "urn:schemas-microsoft-com:vml";
+var wordExtension = "http://schemas.microsoft.com/office/word/2006/wordml";
+var mc = "http://schemas.openxmlformats.org/markup-compatibility/2006";
+function collectShapeCarriers(root, dialect, budget, branches) {
+  const vocabulary = documentDialects[dialect];
+  const bodyRoots = /* @__PURE__ */ new Set();
+  const records = [];
+  const attr = (n, name) => n.attributes.find((a) => !a.namespace && a.localName === name)?.value;
+  const pending = [{ node: root, owner: void 0, group: null, canvas: false, active: true, ancestry: void 0 }];
+  while (pending.length) {
+    const frame = pending.pop();
+    const { node, active, ancestry } = frame;
+    let { owner, group, canvas } = frame;
+    budget.charge("work", 1);
+    if (node.namespace === vocabulary.w && ["drawing", "pict"].includes(node.localName)) {
+      owner = node;
+      group = null;
+      canvas = false;
+    }
+    if (node.namespace === vocabulary.wp && node.localName === "wpc" && owner) canvas = true;
+    let representation;
+    let kind = "shape";
+    if (owner && node.namespace === vocabulary.wp && ["wsp", "wgp", "grpSp"].includes(node.localName)) {
+      representation = "native";
+      kind = node.localName === "wsp" ? "shape" : "group";
+    }
+    if (owner && node.namespace === officeShape && node.localName === "wsp") representation = "office";
+    if (owner && node.namespace === officeGroup && ["wgp", "grpSp"].includes(node.localName)) {
+      representation = "office";
+      kind = "group";
+    }
+    if (owner && node.namespace === vml && ["shape", "arc", "curve", "line", "oval", "polyline", "rect", "roundrect", "group"].includes(node.localName)) {
+      representation = "vml";
+      kind = node.localName === "group" ? "group" : "shape";
+    }
+    if (representation) {
+      budget.charge("retainedBytes", 32);
+      const ancestors = [];
+      for (let link = ancestry; link; link = link.parent) {
+        budget.charge("work", 1);
+        budget.charge("retainedBytes", 24);
+        ancestors.push(link.node);
+      }
+      ancestors.reverse();
+      const candidates = [], admitted = /* @__PURE__ */ new Set(), links = [], ids = [];
+      const enclosing = ancestors.slice(ancestors.indexOf(owner) + 1);
+      const foreignEnvelope = enclosing.some((n) => !(n.namespace === vocabulary.wp && ["inline", "anchor", "wpc", "wgp", "grpSp"].includes(n.localName) || n.namespace === vocabulary.a && ["graphic", "graphicData"].includes(n.localName) || n.namespace === officeGroup && ["wgp", "grpSp"].includes(n.localName) || n.namespace === vml && n.localName === "group" || n.namespace === mc && ["AlternateContent", "Choice", "Fallback"].includes(n.localName)));
+      const scan = [{ n: node, parent: void 0, grandparent: void 0 }];
+      while (scan.length) {
+        const { n, parent, grandparent } = scan.pop();
+        budget.charge("work", 1);
+        if (n !== node && (n.namespace === vocabulary.wp && ["wsp", "wgp", "grpSp"].includes(n.localName) || n.namespace === officeShape && n.localName === "wsp" || n.namespace === officeGroup || n.namespace === vml && ["shape", "group"].includes(n.localName))) continue;
+        if (n.localName === "txbxContent" && [vocabulary.wp, vocabulary.w, documentDialects.transitional.w, wordExtension].includes(n.namespace)) {
+          candidates.push(n);
+          if (parent && grandparent === node && (representation === "native" ? parent.namespace === vocabulary.wp && parent.localName === "txbx" && n.namespace === vocabulary.wp : representation === "office" ? parent.namespace === officeShape && parent.localName === "txbx" && n.namespace === documentDialects.transitional.w : parent.namespace === vml && parent.localName === "textbox" && n.namespace === documentDialects.transitional.w)) admitted.add(n);
+        }
+        if (n.localName === "linkedTxbx" && [vocabulary.wp, officeShape].includes(n.namespace)) links.push(attr(n, "id") ?? "");
+        if (n.localName === "txbx" && [vocabulary.wp, officeShape].includes(n.namespace)) ids.push(attr(n, "id") ?? "0");
+        for (let i = n.children.length - 1; i >= 0; i--) {
+          budget.charge("retainedBytes", 32);
+          scan.push({ n: n.children[i], parent: n, grandparent: parent });
+        }
+      }
+      candidates.forEach((n) => bodyRoots.add(n));
+      const reasons = [];
+      if (foreignEnvelope) reasons.push("foreign-envelope");
+      if (candidates.some((n) => !admitted.has(n))) reasons.push("unsupported-body");
+      if (group) reasons.push("group-contained");
+      if (canvas) reasons.push("canvas");
+      if (candidates.length > 1) reasons.push("multiple-bodies");
+      if (candidates.some((n) => n.namespace === wordExtension)) reasons.push("opaque-body");
+      if (dialect === "strict" && representation !== "native") reasons.push("strict-extension");
+      const expected = representation === "native" ? vocabulary.wp : documentDialects.transitional.w;
+      const bodies = candidates.length === 1 && candidates[0].namespace === expected && admitted.has(candidates[0]) && !reasons.includes("strict-extension") && !foreignEnvelope ? [{ node: candidates[0], wordNamespace: representation === "native" ? vocabulary.w : documentDialects.transitional.w }] : [];
+      if (candidates.length && !bodies.length && !reasons.length) reasons.push("unsupported-body");
+      const style = attr(node, "style") ?? "";
+      for (const declaration of style.split(";")) {
+        const colon = declaration.indexOf(":");
+        if (colon >= 0 && declaration.slice(0, colon).trim().toLowerCase() === "mso-next-textbox" && declaration.slice(colon + 1).trim()) links.push("vml-flow");
+      }
+      if (links.length) reasons.push("linked-flow");
+      records.push({ node, kind, representation, group, bodies, refusalReasons: reasons, active, opaque: !!candidates.length && !bodies.length, support: reasons.length || kind === "group" ? "preserve-only" : "supported", owner: [...ancestors].reverse().find((n) => ["body", "hdr", "ftr", "footnote", "endnote", "comment", "txbxContent"].includes(n.localName) && (n.namespace === vocabulary.w || n.namespace === vocabulary.wp)) ?? root, links, ids, ancestors });
+      if (kind === "group") group = node;
+    }
+    if (node.children.length) budget.charge("retainedBytes", 32);
+    const descendantAncestry = node.children.length ? { node, parent: ancestry } : void 0;
+    for (let i = node.children.length - 1; i >= 0; i--) {
+      const child = node.children[i];
+      const selected = node.namespace === mc && node.localName === "AlternateContent" ? branches.get(node) : void 0;
+      budget.charge("work", 1);
+      budget.charge("retainedBytes", 64);
+      pending.push({ node: child, owner, group, canvas, active: active && (!(node.namespace === mc && node.localName === "AlternateContent") || selected === child), ancestry: descendantAncestry });
+    }
+  }
+  for (const record of records) {
+    for (const other of records) {
+      budget.charge("work", 1);
+      if (record.owner === other.owner && other.links.some((id) => record.ids.includes(id))) {
+        if (!record.refusalReasons.includes("linked-flow")) record.refusalReasons.push("linked-flow");
+      }
+      if (other !== record && other.bodies.some((body) => record.ancestors.includes(body.node))) {
+        if (!record.refusalReasons.includes("nested-box")) record.refusalReasons.push("nested-box");
+        if (!other.refusalReasons.includes("containing-box")) other.refusalReasons.push("containing-box");
+      }
+    }
+    record.support = record.refusalReasons.length || record.kind === "group" ? "preserve-only" : "supported";
+  }
+  return { carriers: records.filter((r) => r.active), rawCarriers: records, bodyRoots };
+}
+
+// packages/safe-bash-docx-engine/src/xml-write.ts
+function containsMath(root, budget) {
+  const pending = [root];
+  while (pending.length) {
+    const node = pending.pop();
+    budget.charge("work", 1);
+    if (node.namespace === mathNamespace(false) || node.namespace === mathNamespace(true)) return true;
+    budget.charge("retainedBytes", node.children.length * 8);
+    for (const child of node.children) pending.push(child);
+  }
+  return false;
+}
+var UnsupportedEditError = class extends Error {
+  code = "unsupported-edit";
+};
+var replaceListPropertyXml = /* @__PURE__ */ Symbol("replace-list-property-xml");
+var replaceCommentRangeXml = /* @__PURE__ */ Symbol("replace-comment-range-xml");
+var replaceNativeTabCollectionXml = /* @__PURE__ */ Symbol("replace-native-tab-collection-xml");
+var sourceRootEnvelope = /* @__PURE__ */ Symbol("source-root-envelope");
+var appendBodyBlocks = /* @__PURE__ */ Symbol("append-body-blocks");
+var insertParagraphBefore = /* @__PURE__ */ Symbol("insert-paragraph-before");
+var insertParagraphAfter = /* @__PURE__ */ Symbol("insert-paragraph-after");
+var insertTableRowXml = /* @__PURE__ */ Symbol("insert-table-row-xml");
+var removeTableRowXml = /* @__PURE__ */ Symbol("remove-table-row-xml");
+var removeNoteBodyXml = /* @__PURE__ */ Symbol("remove-note-body-xml");
+var replaceActiveStyleXml = /* @__PURE__ */ Symbol("replace-active-style-xml");
+var insertActiveLatentStyles = /* @__PURE__ */ Symbol("insert-active-latent-styles");
+var editActiveRelationshipXml = /* @__PURE__ */ Symbol("edit-active-relationship-xml");
+var editActivePropertyXml = /* @__PURE__ */ Symbol("edit-active-property-xml");
+var replaceSplitTextRunXml = /* @__PURE__ */ Symbol("replace-split-text-run-xml");
+var splitNativeTextRunXml = /* @__PURE__ */ Symbol("split-native-text-run-xml");
+var nativeElementSourceTokens = /* @__PURE__ */ Symbol("native-element-source-tokens");
+var nativeXmlTriviaSource = /* @__PURE__ */ Symbol("native-xml-trivia-source");
+var nativeScalarTextSource = /* @__PURE__ */ Symbol("native-scalar-text-source");
+var replaceSplitParagraphXml = /* @__PURE__ */ Symbol("replace-split-paragraph-xml");
+var copiedSplitParagraphProperties = /* @__PURE__ */ Symbol("copied-split-paragraph-properties");
+var editInlineShapeExtentXml = /* @__PURE__ */ Symbol("edit-inline-shape-extent-xml");
+var cloneableRunProperties = new Set("rStyle rFonts b bCs i iCs caps smallCaps strike dstrike outline shadow emboss imprint noProof snapToGrid vanish webHidden color spacing w kern position sz szCs highlight u effect bdr shd fitText vertAlign rtl cs em lang eastAsianLayout specVanish oMath".split(" "));
+var cloneableParagraphProperties = new Set("pPr pStyle keepNext keepLines pageBreakBefore framePr widowControl numPr ilvl numId suppressLineNumbers pBdr top left bottom right between bar start end shd tabs tab suppressAutoHyphens kinsoku wordWrap overflowPunct topLinePunct autoSpaceDE autoSpaceDN bidi adjustRightInd snapToGrid spacing ind contextualSpacing mirrorIndents suppressOverlap jc textDirection textAlignment textboxTightWrap outlineLvl divId cnfStyle rPr sectPr headerReference footerReference footnotePr endnotePr type pgSz pgMar paperSrc pgBorders lnNumType pgNumType cols col formProt vAlign noEndnote titlePg textDirection bidi rtlGutter docGrid printerSettings".split(" "));
+function cloneableRunProperty(element, w, containers, budget, children = (node) => node.children) {
+  budget.charge("work", 1 + element.attributes.length);
+  const storedProperty = (node) => {
+    budget.charge("retainedBytes", 40);
+    const pending = [{ node, index: -1 }];
+    while (pending.length) {
+      const frame = pending.at(-1);
+      if (frame.index === -1) {
+        budget.charge("work", 1);
+        if (frame.node.namespace === w && frame.node.localName !== "rPr" && !cloneableRunProperties.has(frame.node.localName)) return false;
+        frame.index = 0;
+      }
+      const child = frame.node.children[frame.index++];
+      if (!child) {
+        pending.pop();
+        continue;
+      }
+      budget.charge("retainedBytes", 40);
+      pending.push({ node: child, index: -1 });
+    }
+    return true;
+  };
+  return (element.namespace === w && (element.localName === "rPr" || cloneableRunProperties.has(element.localName) && !children(element).length) || element.namespace === "http://schemas.openxmlformats.org/markup-compatibility/2006" || containers.has(element)) && element.attributes.every((attribute) => [w, "http://www.w3.org/2000/xmlns/", "http://www.w3.org/XML/1998/namespace", "http://schemas.openxmlformats.org/markup-compatibility/2006"].includes(attribute.namespace) || attribute.namespace === "" && element.localName === "Choice" && attribute.localName === "Requires") && element.children.every((child) => (child.namespace === w || containers.has(child)) && storedProperty(child)) && children(element).every((child) => cloneableRunProperty(child, w, containers, budget, children));
+}
+function unsupported() {
+  throw new UnsupportedEditError("The XML edit cannot establish faithful preservation.");
+}
+var sourceIndexes = /* @__PURE__ */ new WeakMap();
+var editorOwners = /* @__PURE__ */ new WeakMap();
+function indexSource(document, source, budget) {
+  const cacheable = Object.isFrozen(document);
+  if (cacheable) budget.charge("work", source.length);
+  const cached = cacheable ? sourceIndexes.get(document) : void 0;
+  if (cached?.source === source) {
+    budget.charge("work", cached.work);
+    budget.charge("retainedBytes", cached.retainedBytes);
+    return cached.spans;
+  }
+  const before = cacheable ? budget.usage : void 0;
+  const spans = /* @__PURE__ */ new Map();
+  let offset = source.charCodeAt(0) === 65279 ? 1 : 0;
+  const consume = (value) => {
+    if (!source.startsWith(value, offset)) unsupported();
+    offset += value.length;
+  };
+  const whitespace = () => {
+    while (offset < source.length && " 	\r\n".includes(source[offset])) offset++;
+  };
+  const until = (delimiter) => {
+    const end = source.indexOf(delimiter, offset);
+    if (end < 0) unsupported();
+    return end;
+  };
+  const visit = (root) => {
+    budget.charge("retainedBytes", 64);
+    const pending = [{ node: root }];
+    while (pending.length) {
+      const { node, close } = pending.pop();
+      budget.charge("work", 1);
+      if (close && node.kind === "element") {
+        const contentEnd = offset;
+        consume("</" + node.name);
+        whitespace();
+        consume(">");
+        spans.set(node, { ...close, end: offset, contentEnd, owner: node });
+        continue;
+      }
+      if (node.kind === "element") {
+        const start2 = offset;
+        consume("<" + node.name);
+        for (const attribute of node.attributes) {
+          whitespace();
+          const attributeStart = offset;
+          consume(attribute.name);
+          whitespace();
+          consume("=");
+          whitespace();
+          const quote = source[offset++];
+          if (quote !== '"' && quote !== "'") unsupported();
+          const start3 = offset;
+          offset = until(quote);
+          offset++;
+          spans.set(attribute, { start: start3, end: offset - 1, owner: node, attributeStart, attributeEnd: offset });
+        }
+        whitespace();
+        if (source.startsWith("/>", offset)) {
+          if (node.content.length) unsupported();
+          const contentStart = offset;
+          offset += 2;
+          spans.set(node, { start: start2, end: offset, contentStart, contentEnd: contentStart, empty: true, owner: node });
+        } else {
+          consume(">");
+          const contentStart = offset;
+          budget.charge("retainedBytes", 64 * (node.content.length + 1));
+          pending.push({ node, close: { start: start2, contentStart } });
+          for (let i = node.content.length - 1; i >= 0; i--) pending.push({ node: node.content[i] });
+        }
+        continue;
+      }
+      let suffix = "";
+      if (node.kind === "comment") {
+        consume("<!--");
+        suffix = "-->";
+      } else if (node.kind === "cdata") {
+        consume("<![CDATA[");
+        suffix = "]]>";
+      } else if (node.kind === "processing-instruction") {
+        consume("<?" + node.target);
+        whitespace();
+        suffix = "?>";
+      }
+      const start = offset;
+      if (suffix) offset = until(suffix);
+      else {
+        const next = source.indexOf("<", offset);
+        offset = next < 0 ? source.length : next;
+        if (offset === start) unsupported();
+      }
+      spans.set(node, { start, end: offset, owner: node });
+      offset += suffix.length;
+    }
+  };
+  if (document.root.declaration !== void 0) {
+    consume("<?xml");
+    offset = until("?>") + 2;
+  }
+  for (const node of document.root.prolog ?? []) visit(node);
+  visit(document.root);
+  for (const node of document.root.epilog ?? []) visit(node);
+  if (offset !== source.length) unsupported();
+  if (before) {
+    budget.charge("retainedBytes", 128);
+    const after = budget.usage;
+    sourceIndexes.set(document, { source, spans, work: after.work - before.work, retainedBytes: after.retainedBytes - before.retainedBytes });
+  }
+  return spans;
+}
+function escapeValue(value, attribute) {
+  let escaped = "";
+  for (const char of value) {
+    if (char === "&") escaped += "&amp;";
+    else if (char === "<") escaped += "&lt;";
+    else if (char === ">") escaped += "&gt;";
+    else if (char === "\r") escaped += "&#13;";
+    else if (attribute && char === "\n") escaped += "&#10;";
+    else if (attribute && char === "	") escaped += "&#9;";
+    else if (attribute && char === '"') escaped += "&quot;";
+    else if (attribute && char === "'") escaped += "&apos;";
+    else escaped += char;
+  }
+  return escaped;
+}
+var DocumentXmlEditor = class _DocumentXmlEditor {
+  #budget;
+  #profile;
+  #compatibility;
+  #guardCompatibility = false;
+  #document;
+  #source;
+  #limits;
+  #spans;
+  #patches = /* @__PURE__ */ new Map();
+  #namespaces;
+  #elements;
+  #dialect;
+  #shapes;
+  #boxViews = /* @__PURE__ */ new Map();
+  constructor(bytes, limits = {}, profile = void 0, budget = new DocumentBudget()) {
+    this.#budget = budget;
+    this.#limits = documentXmlSettings(limits, budget);
+    this.#document = parseDocumentXml(bytes, this.#limits, budget);
+    this.#profile = compatibilitySettings(profile === void 0 ? compatibilityProfileForRoot(this.#document.root) : profile);
+    budget.charge("retainedBytes", bytes.length * 8);
+    budget.charge("work", bytes.length * 8);
+    this.#dialect = dialectForNamespace(this.#document.root.namespace);
+    this.#guardCompatibility = this.#dialect !== void 0;
+    this.#source = new TextDecoder(this.#document.encoding, { fatal: true, ignoreBOM: true }).decode(this.#document.bytes);
+    this.#spans = indexSource(this.#document, this.#source, this.#budget);
+    const cacheable = Object.isFrozen(this.#document);
+    if (cacheable) budget.charge("retainedBytes", 128);
+    const cached = cacheable ? editorOwners.get(this.#document) : void 0;
+    if (cached) {
+      this.#elements = cached.elements;
+      this.#namespaces = cached.namespaces;
+      if (!this.#guardCompatibility) for (const node of this.#elements) {
+        if (hasCompatibilityMarkup(node, this.#profile)) {
+          this.#guardCompatibility = true;
+          break;
+        }
+      }
+      return;
+    }
+    const elements = /* @__PURE__ */ new Set();
+    const namespaces = /* @__PURE__ */ new Map();
+    const stack = [this.#document.root];
+    const immutable = budget[documentXmlCache].immutableRoots?.has(this.#document.root) === true;
+    while (stack.length) {
+      const node = stack.pop();
+      if (node.kind === "element") {
+        elements.add(node);
+        if (!this.#guardCompatibility && hasCompatibilityMarkup(node, this.#profile)) this.#guardCompatibility = true;
+        if (!namespaces.has(node.namespaces))
+          namespaces.set(node.namespaces, new Map(node.namespaces));
+        if (!immutable) {
+          for (const attribute of node.attributes) Object.freeze(attribute);
+          Object.freeze(node.content);
+          Object.freeze(node.children);
+          Object.freeze(node.attributes);
+          if (node.prolog) Object.freeze(node.prolog);
+          if (node.epilog) Object.freeze(node.epilog);
+        }
+        for (const child of node.content) stack.push(child);
+        if (node.prolog) for (const child of node.prolog) stack.push(child);
+        if (node.epilog) for (const child of node.epilog) stack.push(child);
+      }
+      if (!immutable) Object.freeze(node);
+    }
+    this.#elements = elements;
+    this.#namespaces = namespaces;
+    if (cacheable) editorOwners.set(this.#document, { elements, namespaces });
+  }
+  get compatibility() {
+    return this.#compatibility ??= new MarkupCompatibility(this.root, this.#profile, this.#budget);
+  }
+  get root() {
+    return this.#document.root;
+  }
+  [sourceRootEnvelope]() {
+    const span = this.#spans.get(this.root);
+    const length = this.#source.length - (span.end - span.start);
+    this.#budget.charge("work", length);
+    this.#budget.charge("retainedBytes", length * 2);
+    return [this.#source.slice(0, span.start), this.#source.slice(span.end)];
+  }
+  get dirtyNodes() {
+    return [...new Set([...this.#patches.keys()].map((token) => this.#spans.get(token).owner))];
+  }
+  /** Every affected native box must admit the operation, even before a no-op edit. */
+  assertShapeEditAllowed(node) {
+    this.#assertOwnedElement(node);
+    if (!this.#dialect) return;
+    const span = this.#spans.get(node);
+    if (!span) unsupported();
+    for (const carrier of this.#shapeCensus().rawCarriers) {
+      for (const body of this.#shapeCensus().bodyRoots) {
+        const bodySpan = this.#spans.get(body);
+        const carrierSpan = this.#spans.get(carrier.node);
+        if (!(carrierSpan.start <= bodySpan.start && bodySpan.end <= carrierSpan.end)) continue;
+        if (span.start <= bodySpan.start && bodySpan.end <= span.end || bodySpan.start <= span.start && span.end <= bodySpan.end) {
+          if (!carrier.active || carrier.refusalReasons.length || !carrier.bodies.some((b) => b.node === body)) unsupported();
+        }
+      }
+    }
+  }
+  #shapeCensus() {
+    return this.#shapes ??= collectShapeCarriers(
+      this.root,
+      this.#dialect,
+      this.#budget,
+      new Map(this.compatibility.branches.map((branch) => [branch.alternateContent, branch.selected]))
+    );
+  }
+  #canEdit(token) {
+    if (this.compatibility.canEdit(token)) return true;
+    if (!this.#dialect) return false;
+    const span = this.#spans.get(token);
+    if (!span) return false;
+    for (const carrier of this.#shapeCensus().carriers) {
+      if (carrier.refusalReasons.length) continue;
+      for (const body of carrier.bodies) {
+        const boundary = this.#spans.get(body.node);
+        if (boundary.contentStart <= span.start && span.end <= boundary.contentEnd) {
+          let view = this.#boxViews.get(body.node);
+          if (!view) {
+            view = new MarkupCompatibility(body.node, this.#profile, this.#budget);
+            this.#boxViews.set(body.node, view);
+          }
+          return view.canEdit(token);
+        }
+      }
+    }
+    return false;
+  }
+  /** Exact admitted source, for engine-authored fragments retaining lexical XML. */
+  [nativeElementSourceTokens](node, omittedAttribute) {
+    this.#assertOwnedElement(node);
+    const span = this.#spans.get(node);
+    const openingEnd = span.empty ? span.end : span.contentStart;
+    const closingStart = span.empty ? span.end : span.contentEnd;
+    this.#budget.charge("work", openingEnd - span.start + span.end - closingStart);
+    this.#budget.charge("retainedBytes", (openingEnd - span.start + span.end - closingStart) * 2 + 16);
+    let opening = this.#source.slice(span.start, openingEnd);
+    if (omittedAttribute) {
+      this.#budget.charge("work", opening.length);
+      this.#budget.charge("retainedBytes", opening.length * 4 + 24);
+      if (!node.attributes.includes(omittedAttribute)) throw new OwnershipError("Expected an attribute owned by this XML element.");
+      if (omittedAttribute.namespace === "http://www.w3.org/2000/xmlns/") unsupported();
+      const attribute = this.#spans.get(omittedAttribute);
+      if (attribute.attributeStart < span.start || attribute.attributeEnd > openingEnd) unsupported();
+      opening = this.#source.slice(span.start, attribute.attributeStart) + this.#source.slice(attribute.attributeEnd, openingEnd);
+    }
+    return [opening, this.#source.slice(closingStart, span.end)];
+  }
+  [nativeXmlTriviaSource](node) {
+    if (!node || typeof node !== "object" || !["comment", "processing-instruction"].includes(node.kind))
+      throw new InputTypeError("Expected an XML comment or processing instruction.");
+    const span = this.#spans.get(node);
+    if (!span) throw new OwnershipError("Expected XML trivia owned by this editor.");
+    let start = span.start;
+    if (node.kind === "comment") start -= 4;
+    else if (node.kind === "processing-instruction") {
+      while (start > 0 && " 	\r\n".includes(this.#source[start - 1])) {
+        this.#budget.charge("work", 1);
+        start--;
+      }
+      start -= node.target.length + 2;
+    }
+    const end = span.end + (node.kind === "comment" ? 3 : 2);
+    this.#budget.charge("work", end - start);
+    this.#budget.charge("retainedBytes", (end - start) * 2);
+    return this.#source.slice(start, end);
+  }
+  [nativeScalarTextSource](node, text, options = {}) {
+    this.#assertOwnedElement(node);
+    if (typeof text !== "string") throw new InputTypeError("Expected XML scalar text.");
+    const content = options.content ?? node.content, span = this.#spans.get(node);
+    const maximum = span.end - span.start + text.length * 6 + node.name.length + 3 + (options.preserveSpace ? 24 : 0);
+    this.#budget.charge("retainedBytes", maximum * 8);
+    this.#budget.charge("work", maximum * 4);
+    const chunks = [];
+    let offset = span.contentStart, replaced = false;
+    for (const token of content) {
+      if (token.kind !== "text" && token.kind !== "cdata") continue;
+      const scalar = this.#spans.get(token);
+      if (!scalar) throw new OwnershipError("Expected owned XML scalar content.");
+      const start = scalar.start - (token.kind === "cdata" ? 9 : 0);
+      const end = scalar.end + (token.kind === "cdata" ? 3 : 0);
+      if (start < offset || end > span.contentEnd) unsupported();
+      chunks.push(this.#source.slice(offset, start), replaced ? "" : escapeValue(text, false));
+      offset = end;
+      replaced = true;
+    }
+    chunks.push(this.#source.slice(offset, span.contentEnd), replaced ? "" : escapeValue(text, false));
+    let source = this.#source.slice(span.start, span.contentStart) + (span.empty ? ">" : "") + chunks.join("") + (span.empty ? `</${node.name}>` : this.#source.slice(span.contentEnd, span.end));
+    if (options.preserveSpace) {
+      const space = node.attributes.find((attribute) => attribute.namespace === "http://www.w3.org/XML/1998/namespace" && attribute.localName === "space");
+      if (space) {
+        const attribute = this.#spans.get(space);
+        source = source.slice(0, attribute.start - span.start) + "preserve" + source.slice(attribute.end - span.start);
+      } else {
+        const index = span.contentStart - span.start - (span.empty ? 0 : 1);
+        source = source.slice(0, index) + ' xml:space="preserve"' + source.slice(index);
+      }
+    }
+    return source;
+  }
+  /** Exact admitted source, for engine-authored fragments retaining lexical XML. */
+  sourceXml(node, replacements = /* @__PURE__ */ new Map(), contentOnly = false) {
+    this.#assertOwnedElement(node);
+    const span = this.#spans.get(node);
+    this.#budget.charge("work", span.end - span.start);
+    this.#budget.charge("retainedBytes", (span.end - span.start) * 2);
+    let offset = contentOnly ? span.contentStart : span.start;
+    const chunks = [];
+    const descendants = [...replacements.keys()];
+    for (const child of descendants) {
+      this.#assertOwnedElement(child);
+      const childSpan = this.#spans.get(child);
+      if (child === node || !childSpan || childSpan.start < span.contentStart || childSpan.end > span.contentEnd) unsupported();
+    }
+    descendants.sort((left, right) => this.#spans.get(left).start - this.#spans.get(right).start);
+    for (const child of descendants) {
+      const replacement = replacements.get(child);
+      if (replacement === void 0) continue;
+      if (typeof replacement !== "string") throw new InputTypeError("Expected XML markup.");
+      const childSpan = this.#spans.get(child);
+      if (childSpan.start < offset) unsupported();
+      this.#budget.charge("work", replacement.length);
+      this.#budget.charge("retainedBytes", replacement.length * 2);
+      chunks.push(this.#source.slice(offset, childSpan.start), replacement);
+      offset = childSpan.end;
+    }
+    chunks.push(this.#source.slice(offset, contentOnly ? span.contentEnd : span.end));
+    return chunks.join("");
+  }
+  /** Replace an owned editable subtree; validate the complete candidate atomically. */
+  replaceElement(node, xml2) {
+    if (typeof xml2 !== "string") throw new InputTypeError("Expected XML markup.");
+    this.#assertOwnedElement(node);
+    if (node === this.root || this.#patches.has(node)) unsupported();
+    this.assertShapeEditAllowed(node);
+    if (this.#guardCompatibility && !this.#canEdit(node)) unsupported();
+    this.#stageReplacement(node, xml2, !this.#canReplaceSubtree(node, (token) => this.#canEdit(token)), true);
+  }
+  [replaceCommentRangeXml](paragraph, xml2) {
+    this.#assertOwnedElement(paragraph);
+    if (typeof xml2 !== "string") throw new InputTypeError("Expected XML markup.");
+    if (!this.#dialect || paragraph.namespace !== documentDialects[this.#dialect].w || paragraph.localName !== "p" || this.#patches.has(paragraph) || !this.#canEdit(paragraph)) unsupported();
+    this.assertShapeEditAllowed(paragraph);
+    this.#stageReplacement(
+      paragraph,
+      xml2,
+      !this.#canReplaceSubtree(paragraph, (token) => this.#canEdit(token)),
+      true,
+      true
+    );
+  }
+  [splitNativeTextRunXml](node, fragments, stage = true, wrap) {
+    this.#assertOwnedElement(node);
+    const children = activeXmlChildren(this, this.#budget), active = children(node);
+    const props = active.filter((child) => child.namespace === node.namespace && child.localName === "rPr");
+    const leaves2 = active.filter((child) => !props.includes(child));
+    const containers = new Set(this.compatibility[compatibilityContainers]);
+    const branchElements = new Set(this.compatibility.branches.flatMap((branch) => branch.alternateContent.children).filter((child) => child.namespace === "http://schemas.openxmlformats.org/markup-compatibility/2006" && ["Choice", "Fallback"].includes(child.localName)));
+    let previousCacheFragment = -1;
+    if (!this.#dialect || node.namespace !== documentDialects[this.#dialect].w || node.localName !== "r" || !this.#canEdit(node) || this.#patches.has(node) || props.length > 1 || !fragments.length || node.attributes.some((attribute) => attribute.namespace !== "http://www.w3.org/2000/xmlns/" && !this.#canEdit(attribute)) || props.some((property) => !cloneableRunProperty(property, node.namespace, containers, this.#budget, children)) || leaves2.some((leaf) => {
+      if (leaf.namespace !== node.namespace || !["t", "delText", "tab", "ptab", "br", "cr", "noBreakHyphen", "softHyphen", "lastRenderedPageBreak", "footnoteRef", "endnoteRef", "annotationRef"].includes(leaf.localName)) return true;
+      if (leaf.localName === "lastRenderedPageBreak") {
+        const original = this.sourceXml(leaf);
+        let copies = 0;
+        for (const [index, fragment] of fragments.entries()) {
+          this.#budget.charge("work", 1);
+          if (!fragment.content.has(leaf)) continue;
+          if (fragment.content.get(leaf) !== original || index < previousCacheFragment) return true;
+          previousCacheFragment = index;
+          copies++;
+        }
+        return leaf.children.length > 0 || copies !== 1;
+      }
+      return leaf.content.some((content) => content.kind !== "text") || leaf.attributes.some((attribute) => attribute.namespace !== "http://www.w3.org/2000/xmlns/" && !this.#canEdit(attribute));
+    }) || fragments.some((fragment) => [...fragment.content.keys()].some((leaf) => !leaves2.includes(leaf)))) unsupported();
+    const selected = /* @__PURE__ */ new Set([...leaves2, ...props]);
+    const paths = /* @__PURE__ */ new Set();
+    this.#budget.charge("retainedBytes", 40);
+    const traversal = [{ element: node, index: -1, found: false }];
+    while (traversal.length) {
+      const frame = traversal.at(-1), element = frame.element;
+      if (frame.index === -1) {
+        this.#budget.charge("work", 1);
+        frame.index = 0;
+        if (selected.has(element)) {
+          paths.add(element);
+          traversal.pop();
+          if (traversal.length) traversal.at(-1).found = true;
+          continue;
+        }
+      }
+      const child = element.children[frame.index++];
+      if (child) {
+        this.#budget.charge("retainedBytes", 40);
+        traversal.push({ element: child, index: -1, found: false });
+        continue;
+      }
+      if (frame.found) {
+        if (element !== node && !containers.has(element)) unsupported();
+        if (element.content.some((content) => (content.kind === "text" || content.kind === "cdata") && content.text.trim()) || element !== node && element.attributes.some((attribute) => !["http://www.w3.org/2000/xmlns/", "http://www.w3.org/XML/1998/namespace", "http://schemas.openxmlformats.org/markup-compatibility/2006"].includes(attribute.namespace) && !(attribute.namespace === "" && element.localName === "Choice" && attribute.localName === "Requires"))) unsupported();
+        paths.add(element);
+      }
+      traversal.pop();
+      if (frame.found && traversal.length) traversal.at(-1).found = true;
+    }
+    const open = (element, attributes = element.attributes) => `<${element.name}${[...element.namespaces].filter(([prefix]) => prefix !== "xml").map(([prefix, uri]) => ` ${prefix ? "xmlns:" + prefix : "xmlns"}="${escapeValue(uri, true)}"`).join("")}${attributes.filter((attribute) => attribute.namespace !== "http://www.w3.org/2000/xmlns/").map((attribute) => ` ${attribute.name}="${escapeValue(attribute.value, true)}"`).join("")}>`;
+    const markup = fragments.map((fragment, index) => {
+      const patches = new Map(leaves2.map((leaf) => [leaf, fragment.content.get(leaf) ?? ""]));
+      if (props[0]) patches.set(props[0], index ? copiedNativeProperties(fragment.properties, props[0], this.root, this.#profile, this.#budget) : fragment.properties);
+      if (index) {
+        this.#budget.charge("retainedBytes", 40);
+        const pending = [{ element: node, index: 0 }];
+        while (pending.length) {
+          const frame = pending.at(-1), child = frame.element.children[frame.index++];
+          this.#budget.charge("work", 1);
+          if (!child) {
+            pending.pop();
+            continue;
+          }
+          if (selected.has(child)) continue;
+          if (paths.has(child)) {
+            this.#budget.charge("retainedBytes", 40);
+            pending.push({ element: child, index: 0 });
+          } else if (branchElements.has(child)) {
+            const attributes = child.attributes.filter((attribute) => ["http://www.w3.org/2000/xmlns/", "http://schemas.openxmlformats.org/markup-compatibility/2006"].includes(attribute.namespace) || attribute.namespace === "" && child.localName === "Choice" && attribute.localName === "Requires");
+            patches.set(child, attributes.length === child.attributes.length ? this[nativeElementSourceTokens](child).join("") : open(child, attributes) + `</${child.name}>`);
+          } else patches.set(child, "");
+        }
+      }
+      let content;
+      if (!index) content = this.sourceXml(node, patches, true);
+      else {
+        const chunks = [];
+        this.#budget.charge("retainedBytes", 48);
+        const pending = [{ element: node, index: 0, closing: "" }];
+        while (pending.length) {
+          const frame = pending.at(-1), item = frame.element.content[frame.index++];
+          this.#budget.charge("work", 1);
+          if (!item) {
+            pending.pop();
+            if (pending.length) chunks.push(frame.closing);
+            continue;
+          }
+          if (item.kind !== "element") {
+            if (item.kind === "text" || item.kind === "cdata") chunks.push(escapeValue(item.text, false));
+            continue;
+          }
+          this.#budget.charge("work", 1 + item.content.length);
+          const replacement = patches.get(item);
+          if (replacement !== void 0) chunks.push(replacement);
+          else if (!paths.has(item)) chunks.push(this.sourceXml(item));
+          else {
+            this.#budget.charge("retainedBytes", 48);
+            const [opening, closing] = this[nativeElementSourceTokens](item);
+            chunks.push(opening);
+            pending.push({ element: item, index: 0, closing });
+          }
+        }
+        content = chunks.join("");
+      }
+      return open(node) + (props.length ? "" : fragment.properties) + content + `</${node.name}>`;
+    });
+    const wrapped = wrap ? markup.map((fragment, index) => {
+      const result = wrap(fragment, index);
+      if (typeof result !== "string") throw new InputTypeError("Expected XML markup.");
+      return result;
+    }) : markup;
+    this.assertShapeEditAllowed(node);
+    if (stage) this.#stageReplacement(node, wrapped.join(""), false, true);
+    return wrapped;
+  }
+  [replaceSplitParagraphXml](node, markup) {
+    this.#assertOwnedElement(node);
+    const children = activeXmlChildren(this, this.#budget);
+    if (!this.#dialect || node.namespace !== documentDialects[this.#dialect].w || node.localName !== "p" || !this.#canEdit(node) || this.#patches.has(node) || children(node).some((child) => child.namespace !== node.namespace || !["pPr", "r", "bookmarkStart", "bookmarkEnd", "commentRangeStart", "commentRangeEnd", "proofErr", "permStart", "permEnd"].includes(child.localName))) unsupported();
+    for (const run of children(node).filter((child) => child.localName === "r")) {
+      if (children(run).some((child) => child.namespace !== node.namespace || !["rPr", "t", "tab", "ptab", "br", "cr", "noBreakHyphen", "softHyphen", "lastRenderedPageBreak", "footnoteRef", "endnoteRef", "annotationRef"].includes(child.localName))) unsupported();
+    }
+    this.assertShapeEditAllowed(node);
+    this.#stageReplacement(node, markup, false, true);
+  }
+  [copiedSplitParagraphProperties](paragraph, props) {
+    this.#assertOwnedElement(paragraph);
+    this.#assertOwnedElement(props);
+    const children = activeXmlChildren(this, this.#budget), containers = new Set(this.compatibility[compatibilityContainers]);
+    const validate = (node) => {
+      this.#budget.charge("work", 1 + node.attributes.length);
+      if (node.namespace === paragraph.namespace && node.localName === "sectPr" && this.#canEdit(node)) return;
+      if (!this.#canEdit(node) || node.namespace !== paragraph.namespace || !(cloneableParagraphProperties.has(node.localName) || cloneableRunProperties.has(node.localName)) || node.attributes.some((attribute) => !["http://www.w3.org/2000/xmlns/", "http://www.w3.org/XML/1998/namespace", "http://schemas.openxmlformats.org/markup-compatibility/2006"].includes(attribute.namespace) && !this.#canEdit(attribute)) || node.children.some((child) => child.namespace !== paragraph.namespace && !containers.has(child)) || node.content.some((item) => item.kind !== "element" && (item.kind !== "text" || item.text.trim()))) unsupported();
+      for (const child of children(node)) validate(child);
+    };
+    if (props.localName !== "pPr" || !children(paragraph).includes(props)) unsupported();
+    validate(props);
+    return copiedNativeProperties(this.sourceXml(props), props, this.root, this.#profile, this.#budget, true);
+  }
+  /** Native formatting alternatives can follow each fragment of a split run. */
+  [replaceSplitTextRunXml](node, xml2) {
+    this.#assertOwnedElement(node);
+    const containers = new Set(this.compatibility[compatibilityContainers]);
+    if (!this.#dialect || node.namespace !== documentDialects[this.#dialect].w || node.localName !== "r" || node.attributes.some((attribute) => attribute.namespace !== "http://www.w3.org/2000/xmlns/" && !this.#canEdit(attribute)) || node.children.some((child) => child.namespace !== node.namespace || !["rPr", "t", "tab", "ptab", "br", "cr", "noBreakHyphen", "softHyphen", "lastRenderedPageBreak", "footnoteRef", "endnoteRef", "annotationRef"].includes(child.localName) || (child.localName === "rPr" ? !cloneableRunProperty(child, node.namespace, containers, this.#budget) : child.children.length > 0 || child.localName !== "lastRenderedPageBreak" && child.attributes.some((attribute) => attribute.namespace !== "http://www.w3.org/2000/xmlns/" && !this.#canEdit(attribute))))) {
+      this.replaceElement(node, xml2);
+      return;
+    }
+    this.assertShapeEditAllowed(node);
+    if (!this.#canEdit(node) || this.#patches.has(node)) unsupported();
+    const caches = node.children.filter((child) => child.localName === "lastRenderedPageBreak");
+    if (caches.length) {
+      const bindings = [...node.namespaces].filter(([prefix]) => prefix !== "xml").map(([prefix, uri]) => ` ${prefix ? "xmlns:" + prefix : "xmlns"}="${escapeValue(uri, true)}"`).join("");
+      const candidate = new _DocumentXmlEditor(new TextEncoder().encode(`<fragment${bindings}>${xml2}</fragment>`), this.#limits, this.#profile, this.#budget);
+      const retained = [];
+      const collect = (parent) => {
+        this.#budget.charge("work", 1 + parent.children.length);
+        for (const child of parent.children) {
+          if (child.namespace === node.namespace && child.localName === "lastRenderedPageBreak") {
+            if (parent.namespace !== node.namespace || parent.localName !== "r" || child.children.length) unsupported();
+            retained.push(child);
+          }
+          collect(child);
+        }
+      };
+      collect(candidate.root);
+      if (retained.length !== caches.length || caches.some((cache, index) => {
+        const after = retained[index];
+        this.#budget.charge("work", 1 + cache.namespaces.size);
+        return candidate.sourceXml(after) !== this.sourceXml(cache) || after.namespaces.size !== cache.namespaces.size || [...cache.namespaces].some(([prefix, uri]) => after.namespaces.get(prefix) !== uri);
+      })) unsupported();
+    }
+    this.#stageReplacement(node, xml2, false, true);
+  }
+  #canReplaceSubtree(node, canEdit) {
+    const pending = [node];
+    while (pending.length) {
+      const element = pending.pop();
+      this.#budget.charge("work", 1);
+      if (this.#guardCompatibility && (!canEdit(element) || element.attributes.some((attribute) => attribute.namespace !== "http://www.w3.org/2000/xmlns/" && !canEdit(attribute)))) return false;
+      for (let index = element.children.length - 1; index >= 0; index--) pending.push(element.children[index]);
+    }
+    return true;
+  }
+  /** Resolve the selected declaration, retaining its physical compatibility carrier. */
+  [replaceActiveStyleXml](node, xml2) {
+    if (typeof xml2 !== "string") throw new InputTypeError("Expected XML markup.");
+    if (!this.#elements.has(node) || this.#patches.has(node) || !this.#dialect || this.root.namespace !== documentDialects[this.#dialect].w || this.root.localName !== "styles" || node.namespace !== this.root.namespace || node.localName !== "style" || !activeXmlChildren(this, this.#budget)(this.root).includes(node)) unsupported();
+    const view = this.compatibility;
+    if (!this.#canEdit(node)) unsupported();
+    this.#stageReplacement(node, xml2, !this.#canReplaceSubtree(node, (token) => view.canEdit(token)), true);
+  }
+  [insertActiveLatentStyles]() {
+    if (!this.#dialect || this.root.namespace !== documentDialects[this.#dialect].w || this.root.localName !== "styles" || this.#patches.size) unsupported();
+    const children = activeXmlChildren(this, this.#budget)(this.root);
+    if (children.some((node) => node.namespace === this.root.namespace && node.localName === "latentStyles")) unsupported();
+    const markup = `<st:latentStyles xmlns:st="${this.root.namespace}"/>`;
+    const firstStyle = children.find((node) => node.namespace === this.root.namespace && node.localName === "style");
+    if (!firstStyle) {
+      this.insertChildren(this.root, markup);
+      return;
+    }
+    if (!this.#canEdit(firstStyle)) unsupported();
+    const containingParent = (parent2) => {
+      this.#budget.charge("work", 1);
+      if (parent2.children.includes(firstStyle)) return parent2;
+      for (const child of parent2.children) {
+        const found = containingParent(child);
+        if (found) return found;
+      }
+      return void 0;
+    };
+    const parent = containingParent(this.root);
+    if (!parent) unsupported();
+    this.#stageInsertion(parent, markup, firstStyle);
+  }
+  /** Change native fields in the selected row without reconstructing its carrier. */
+  [editActiveRelationshipXml](node, values) {
+    if (!this.#elements.has(node) || !relationshipXmlRows(this.root, this.#budget).some((row) => row.element === node)) unsupported();
+    const span = this.#spans.get(node);
+    for (const patched of this.#patches.keys()) {
+      const other = this.#spans.get(patched);
+      if (span.start < other.end && other.start < span.end) unsupported();
+    }
+    if (values === null) {
+      this.#stageReplacement(node, "");
+      return;
+    }
+    const patches = [];
+    let inserted = 0;
+    for (const [name, value] of Object.entries(values)) {
+      if (!["Type", "Target", "TargetMode"].includes(name) || value !== null && typeof value !== "string") throw new InputTypeError("Expected native relationship fields.");
+      const attribute = node.attributes.find((attribute2) => !attribute2.namespace && attribute2.localName === name);
+      if (attribute) {
+        if (attribute.value === value) continue;
+        const field = this.#spans.get(attribute);
+        patches.push(value === null ? { start: field.attributeStart, end: field.attributeEnd, value: "" } : { start: field.start, end: field.end, value: escapeValue(value, true) });
+      } else if (value !== null) {
+        const offset = span.empty ? span.contentStart : span.contentStart - 1;
+        patches.push({ start: offset, end: offset, value: ` ${name}="${escapeValue(value, true)}"` });
+        inserted++;
+      }
+    }
+    if (!patches.length) return;
+    let source = this.#source.slice(span.start, span.end);
+    for (const patch of patches.sort((left, right) => right.start - left.start))
+      source = source.slice(0, patch.start - span.start) + patch.value + source.slice(patch.end - span.start);
+    this.#acceptOwnedPatch(node, source, inserted);
+  }
+  /** The list domain validates active references and retains every other token. */
+  [replaceListPropertyXml](node, xml2) {
+    if (typeof xml2 !== "string") throw new InputTypeError("Expected XML markup.");
+    if (!this.#elements.has(node) || this.#patches.has(node) || !this.#dialect || node.namespace !== documentDialects[this.#dialect].w || node.localName !== "pPr") unsupported();
+    this.assertShapeEditAllowed(node);
+    this.#stageReplacement(node, xml2);
+  }
+  #stageReplacement(node, xml2, preserveOpaque = false, checkMath = false, preflightOwnership = false) {
+    this.#budget.charge("retainedBytes", xml2.length * 8);
+    this.#budget.charge("work", xml2.length * 4);
+    this.#patches.set(node, xml2);
+    try {
+      const bindings = [...node.namespaces].filter(([prefix]) => prefix !== "xml").map(([prefix, value]) => ` ${prefix ? "xmlns:" + prefix : "xmlns"}="${escapeValue(value, true)}"`).join("");
+      const fragment = parseDocumentXml(new TextEncoder().encode(`<fragment${bindings}>${xml2}</fragment>`), this.#limits, this.#budget);
+      if (checkMath && containsMath(fragment.root, this.#budget)) preserveOpaque = true;
+      this.#budget.charge("retainedBytes", 64 + fragment.root.content.length * 8);
+      const pending = [...fragment.root.content];
+      let inserted = 0;
+      while (pending.length) {
+        const token = pending.pop();
+        this.#budget.charge("work", 1);
+        inserted++;
+        if (token.kind === "element") {
+          inserted += token.attributes.length;
+          this.#budget.charge("work", token.attributes.length);
+          this.#budget.charge("retainedBytes", token.content.length * 8);
+          for (const child of token.content) pending.push(child);
+        }
+      }
+      if (!preflightOwnership) this.#budget.charge("insertedNodes", inserted);
+      const serialized = this.serialize();
+      this.#budget[documentXmlCache].admitted?.add(serialized);
+      const candidate = parseDocumentXml(serialized, this.#limits, this.#budget);
+      if (this.#dialect) validateXmlDialect(candidate.root, this.#dialect, this.#profile, this.#budget);
+      if (preserveOpaque && opaqueXmlContent(this.root, this.#budget, this.#profile) !== opaqueXmlContent(candidate.root, this.#budget, this.#profile)) unsupported();
+      if (preflightOwnership) this.#budget.charge("insertedNodes", inserted);
+    } catch (error) {
+      this.#patches.delete(node);
+      throw error;
+    }
+  }
+  /** Explicit bounded math authority; generic subtree replacement remains conservative. */
+  replaceEquationElement(node, markup) {
+    this.#assertOwnedElement(node);
+    if (typeof markup !== "string") throw new InputTypeError("Expected equation markup.");
+    if (!this.#elements.has(node) || node === this.root || this.#patches.has(node) || !this.#dialect) unsupported();
+    const namespace = mathNamespace(this.#dialect === "strict");
+    if (node.namespace !== namespace || !["oMath", "oMathPara"].includes(node.localName) || inspectEquationFragment(node, namespace, this.#budget).length) unsupported();
+    const fragment = admitEquationFragment(new TextEncoder().encode(markup), namespace, this.#budget);
+    if (fragment.root.localName !== node.localName) unsupported();
+    this.#assertEquationHost(node);
+    this.assertShapeEditAllowed(node);
+    this.#stageReplacement(node, fragment.xml);
+  }
+  /** Append one bounded math root without granting generic compatibility insertion. */
+  appendEquationElement(paragraph, markup) {
+    this.#assertOwnedElement(paragraph);
+    if (typeof markup !== "string") throw new InputTypeError("Expected equation markup.");
+    if (!this.#elements.has(paragraph) || this.#patches.has(paragraph) || !this.#dialect || paragraph.namespace !== documentDialects[this.#dialect].w || paragraph.localName !== "p") unsupported();
+    const fragment = admitEquationFragment(new TextEncoder().encode(markup), mathNamespace(this.#dialect === "strict"), this.#budget);
+    this.#assertEquationHost(paragraph);
+    this.assertShapeEditAllowed(paragraph);
+    this.#stageInsertion(paragraph, fragment.xml);
+  }
+  #assertEquationHost(node) {
+    const namespace = mathNamespace(this.#dialect === "strict"), w = documentDialects[this.#dialect].w;
+    let chain;
+    const search = (current, parents) => {
+      this.#budget.charge("work", 1);
+      if (current === node) {
+        chain = [...parents, current];
+        return;
+      }
+      for (const child of current.children) {
+        if (chain) return;
+        search(child, [...parents, current]);
+      }
+    };
+    search(this.root, []);
+    if (!chain) unsupported();
+    let paragraphIndex = -1;
+    for (let i = chain.length - 1; i >= 0; i--) if (chain[i].namespace === w && chain[i].localName === "p") {
+      paragraphIndex = i;
+      break;
+    }
+    if (paragraphIndex < 0) unsupported();
+    const native = ["document", "body", "hdr", "ftr", "footnotes", "footnote", "endnotes", "endnote", "comments", "comment", "tbl", "tr", "tc", "p"];
+    const mc2 = "http://schemas.openxmlformats.org/markup-compatibility/2006";
+    if (chain.slice(0, paragraphIndex + 1).some((n) => n.namespace === w ? !native.includes(n.localName) : n.namespace !== mc2 || !["AlternateContent", "Choice", "Fallback"].includes(n.localName)) || chain.slice(paragraphIndex + 1, -1).some((n) => n.namespace !== mc2 || !["AlternateContent", "Choice", "Fallback"].includes(n.localName))) unsupported();
+    const paragraph = chain[paragraphIndex], view = this.compatibility, active = /* @__PURE__ */ new Set();
+    const projected = (content) => {
+      for (const item of content) {
+        this.#budget.charge("work", 1);
+        if ("source" in item) {
+          active.add(item.source);
+          this.#budget.charge("retainedBytes", 32);
+          if (item.disposition === "understood") projected(item.content);
+        }
+      }
+    };
+    projected(view.content);
+    if (!active.has(node) || !active.has(paragraph)) unsupported();
+    const check = (current) => {
+      this.#budget.charge("work", 1 + current.attributes.length);
+      if (current.namespace === mc2 && current.localName === "AlternateContent") {
+        view.branches.find((b) => b.alternateContent === current)?.selected?.children.forEach(check);
+        return;
+      }
+      if (!active.has(current)) return;
+      if (![w, namespace].includes(current.namespace) || current.namespace === w && ["sdt", "fldSimple", "fldChar", "instrText", "ins", "del", "moveFrom", "moveTo", "pPrChange", "rPrChange", "moveFromRangeStart", "moveFromRangeEnd", "moveToRangeStart", "moveToRangeEnd"].includes(current.localName) || current.attributes.some((a) => ![w, namespace, mc2, "", "http://www.w3.org/XML/1998/namespace", "http://www.w3.org/2000/xmlns/"].includes(a.namespace))) unsupported();
+      current.children.forEach(check);
+    };
+    check(paragraph);
+    assertOutsideRevisionRanges(this.root, paragraph, this.#budget, view.branches);
+  }
+  /** Replace only scalar text content while preserving the exact owned element shell. */
+  replaceScalarText(node, text) {
+    if (typeof text !== "string") throw new InputTypeError("Expected an XML text string.");
+    this.#assertOwnedElement(node);
+    if (this.#patches.has(node) || node.children.length) unsupported();
+    if (this.#guardCompatibility && (!this.#canEdit(node) || node.content.some((token) => !this.#canEdit(token)))) unsupported();
+    this.assertShapeEditAllowed(node);
+    this.#stageScalarText(node, text);
+  }
+  /** Preserve original tab tokens while admitting a proven insertion or position move. */
+  [replaceNativeTabCollectionXml](owner, markup, tabs, leaf, position, moving) {
+    this.#assertOwnedElement(owner);
+    this.#assertOwnedElement(tabs);
+    if (this.#guardCompatibility && !this.#canEdit(owner)) unsupported();
+    this.assertShapeEditAllowed(owner);
+    const ownerSpan = this.#spans.get(owner);
+    for (const patched of this.#patches.keys()) {
+      const span = this.#spans.get(patched);
+      if (ownerSpan.start < span.end && span.start < ownerSpan.end) unsupported();
+    }
+    const children = activeXmlChildren(this, this.#budget), stops = children(tabs).filter((n) => n.namespace === tabs.namespace && n.localName === "tab");
+    if (!this.#dialect || tabs.namespace !== documentDialects[this.#dialect].w || tabs.localName !== "tabs" || !this.#canEdit(tabs) || !Number.isSafeInteger(position) || position < -2147483648 || position > 2147483647 || moving && (!stops.includes(moving) || !this.#canEdit(moving))) unsupported();
+    const bindings = [...tabs.namespaces].filter(([p]) => p !== "xml").map(([p, uri]) => ` ${p ? "xmlns:" + p : "xmlns"}="${escapeValue(uri, true)}"`).join("");
+    const fragmentSource = `<fragment${bindings}>${leaf}</fragment>`, fragment = parseDocumentXml(new TextEncoder().encode(fragmentSource), this.#limits, this.#budget), added = fragment.root.children[0];
+    if (fragment.root.content.length !== 1 || !added || added.namespace !== tabs.namespace || added.localName !== "tab" || added.attributes.find((a) => a.namespace === tabs.namespace && a.localName === "pos")?.value !== String(position)) unsupported();
+    const attributes = (node, omitPosition = false) => node.attributes.filter((a) => a.namespace !== "http://www.w3.org/2000/xmlns/" && !(omitPosition && a.namespace === tabs.namespace && a.localName === "pos")).map((a) => [a.namespace, a.localName, a.value]).sort();
+    const spans = indexSource(fragment, fragmentSource, this.#budget), addedSpan = spans.get(added);
+    if (moving) {
+      if (JSON.stringify(attributes(added, true)) !== JSON.stringify(attributes(moving, true)) || JSON.stringify([...added.namespaces]) !== JSON.stringify([...moving.namespaces]) || fragmentSource.slice(addedSpan.contentStart, addedSpan.contentEnd) !== this.sourceXml(moving, /* @__PURE__ */ new Map(), true)) unsupported();
+    } else if (added.content.length || added.attributes.some((a) => a.namespace !== "http://www.w3.org/2000/xmlns/" && (a.namespace !== tabs.namespace || !["pos", "val", "leader"].includes(a.localName)))) unsupported();
+    const next = stops.find((n) => n !== moving && storedMeasure(n.attributes.find((a) => a.namespace === tabs.namespace && a.localName === "pos")?.value ?? "").emu > position * 635), patches = /* @__PURE__ */ new Map();
+    if (moving) patches.set(moving, "");
+    if (next) patches.set(next, leaf + this.sourceXml(next));
+    const expected = this.sourceXml(tabs, patches, true) + (next ? "" : leaf);
+    const pathTo = (root, target) => {
+      this.#budget.charge("work", 1);
+      if (root === target) return [];
+      for (const [i, child] of root.children.entries()) {
+        const path = pathTo(child, target);
+        if (path) return [i, ...path];
+      }
+      return void 0;
+    };
+    const ownerPath = pathTo(this.root, owner);
+    if (!ownerPath || owner === this.root || !pathTo(owner, tabs)) unsupported();
+    this.#acceptOwnedPatch(owner, markup, moving ? 0 : 1);
+    try {
+      const candidate = parseDocumentXml(this.serialize(), this.#limits, this.#budget), source = new TextDecoder(candidate.encoding, { fatal: true, ignoreBOM: true }).decode(candidate.bytes), projected = activeXmlChildren(candidate.root, this.#budget);
+      let afterOwner = candidate.root;
+      for (const index of ownerPath) afterOwner = afterOwner.children[index];
+      const afterProps = afterOwner.localName === "pPr" ? afterOwner : projected(afterOwner).find((n) => n.namespace === tabs.namespace && n.localName === "pPr"), afterTabs = afterOwner.localName === "tabs" ? afterOwner : afterProps && projected(afterProps).find((n) => n.namespace === tabs.namespace && n.localName === "tabs");
+      if (!afterTabs) unsupported();
+      const candidateSpans = indexSource(candidate, source, this.#budget), span = candidateSpans.get(afterTabs);
+      if (source.slice(span.contentStart, span.contentEnd) !== expected || JSON.stringify(attributes(afterTabs)) !== JSON.stringify(attributes(tabs)) || JSON.stringify([...afterTabs.namespaces]) !== JSON.stringify([...tabs.namespaces])) unsupported();
+      if (moving) {
+        const afterStops = projected(afterTabs).filter((n) => n.namespace === tabs.namespace && n.localName === "tab"), moved = afterStops[stops.filter((n) => n !== moving && storedMeasure(n.attributes.find((a) => a.namespace === tabs.namespace && a.localName === "pos")?.value ?? "").emu <= position * 635).length];
+        const inheritedContext = (root, target) => {
+          const path = pathTo(root, target);
+          if (!path) unsupported();
+          const context = /* @__PURE__ */ new Map();
+          let node = root;
+          for (const index of [...path, -1]) {
+            for (const a of node.attributes) if (a.namespace === "http://www.w3.org/XML/1998/namespace" && ["lang", "space", "base"].includes(a.localName)) context.set(a.localName, a.localName === "base" ? [...context.get("base") ?? [], a.value] : [a.value]);
+            if (index !== -1) node = node.children[index];
+          }
+          return JSON.stringify([...context]);
+        };
+        if (!moved || inheritedContext(this.root, moving) !== inheritedContext(candidate.root, moved)) unsupported();
+      }
+      const restoreTabs = (node) => {
+        this.#budget.charge("work", 1 + node.children.length + node.content.length);
+        this.#budget.charge("retainedBytes", 192 + node.children.length * 64 + node.content.length * 8);
+        if (node === afterTabs) return tabs;
+        const children2 = new Map(node.children.map((child) => [child, restoreTabs(child)]));
+        return { ...node, children: [...children2.values()], content: node.content.map((item) => item.kind === "element" ? children2.get(item) : item) };
+      };
+      if (opaqueXmlContent(this.root, this.#budget, this.#profile) !== opaqueXmlContent(restoreTabs(candidate.root), this.#budget, this.#profile)) unsupported();
+    } catch (error) {
+      this.#patches.delete(owner);
+      throw error;
+    }
+  }
+  /** Resolve native property ownership before editing within its physical MCE carrier. */
+  [editActivePropertyXml](node, value) {
+    if (value !== null && typeof value !== "string") throw new InputTypeError("Expected scalar property text or removal.");
+    if (!this.#elements.has(node) || this.#patches.size) unsupported();
+    for (const dialect of ["strict", "transitional"]) for (const group of ["core", "extended", "custom"]) {
+      const definition = propertyGroupDefinition(group, dialect);
+      if (this.root.namespace !== definition.namespace || this.root.localName !== definition.root) continue;
+      const property = readPropertyNodes(this.root, group, dialect, this.#budget).find((property2) => property2.node === node);
+      if (!property?.value?.writable || !property.valueNode || !property.valueContent) unsupported();
+      if (value === null) {
+        if (property.valueNode.children.length || node !== property.valueNode && (node.children.length !== 1 || node.children[0] !== property.valueNode)) unsupported();
+        const view = new MarkupCompatibility(node, this.#profile, this.#budget);
+        if (!this.#canReplaceSubtree(node, (token) => view.canEdit(token))) unsupported();
+        this.#stageReplacement(node, "");
+      } else this.#stageScalarText(property.valueNode, value, property.valueContent);
+      return;
+    }
+    unsupported();
+  }
+  #stageScalarText(node, text, content = node.content) {
+    const length = content.reduce((size, token) => size + (token.kind === "text" || token.kind === "cdata" ? token.text.length : 0), 0);
+    this.#budget.charge("retainedBytes", length * 2 + content.length * 16);
+    this.#budget.charge("work", length + content.length);
+    if (content.filter((token) => token.kind === "text" || token.kind === "cdata").map((token) => token.text).join("") === text) return;
+    this.#budget.charge("insertedNodes", text.length ? 1 : 0);
+    const patch = this[nativeScalarTextSource](node, text, { content });
+    this.#patches.set(node, patch);
+    try {
+      const candidate = parseDocumentXml(this.serialize(), this.#limits, this.#budget);
+      if (this.#dialect) validateXmlDialect(candidate.root, this.#dialect, this.#profile, this.#budget);
+    } catch (error) {
+      this.#patches.delete(node);
+      throw error;
+    }
+  }
+  [removeNoteBodyXml](note) {
+    this.#assertOwnedElement(note);
+    if (!this.#dialect || !["footnote", "endnote"].includes(note.localName) || note.namespace !== documentDialects[this.#dialect].w || this.root.localName !== note.localName + "s" || !activeXmlChildren(this, this.#budget)(this.root).includes(note) || this.#patches.has(note)) unsupported();
+    this.assertShapeEditAllowed(note);
+    const containers = new Set(this.compatibility[compatibilityContainers]), pending = [note];
+    while (pending.length) {
+      const node = pending.pop();
+      this.#budget.charge("work", 1 + node.attributes.length);
+      if (!containers.has(node) && (!this.#canEdit(node) || node.attributes.some((a) => !["http://www.w3.org/2000/xmlns/", "http://www.w3.org/XML/1998/namespace"].includes(a.namespace) && !this.#canEdit(a)))) unsupported();
+      this.#budget.charge("retainedBytes", node.children.length * 8);
+      for (const child of node.children) pending.push(child);
+    }
+    this.#stageReplacement(note, "", false, true);
+  }
+  /** Inserts admitted markup at an owned child boundary, retaining source tokens. */
+  [appendBodyBlocks](body, xml2) {
+    if (typeof xml2 !== "string") throw new InputTypeError("Expected XML markup.");
+    const children = activeXmlChildren(this, this.#budget);
+    if (!this.#dialect || this.root.localName !== "document" || body.namespace !== this.root.namespace || body.localName !== "body" || !children(this.root).includes(body)) unsupported();
+    const sections = children(body).filter((node) => node.namespace === body.namespace && node.localName === "sectPr");
+    if (sections.length > 1) unsupported();
+    const section = sections[0], target = section ?? body;
+    let path;
+    const locate = (node, current) => {
+      this.#budget.charge("work", 1);
+      if (node === target) {
+        path = current;
+        return;
+      }
+      for (const [index, child] of node.children.entries()) {
+        if (path) break;
+        this.#budget.charge("retainedBytes", (current.length + 1) * 8);
+        locate(child, [...current, index]);
+      }
+    };
+    locate(this.root, []);
+    if (!path) unsupported();
+    const insertionPath = section ? path : [...path, body.children.length];
+    let parent = this.root;
+    for (const index of insertionPath.slice(0, -1)) parent = parent.children[index];
+    this.#stageInsertion(parent, xml2, section);
+    return insertionPath;
+  }
+  [insertParagraphBefore](paragraph, xml2) {
+    if (typeof xml2 !== "string") throw new InputTypeError("Expected XML markup.");
+    this.#assertOwnedElement(paragraph);
+    if (!this.#dialect || paragraph.namespace !== documentDialects[this.#dialect].w || paragraph.localName !== "p" || !this.#canEdit(paragraph)) unsupported();
+    this.assertShapeEditAllowed(paragraph);
+    const fragment = parseDocumentXml(new TextEncoder().encode(`<root>${xml2}</root>`), this.#limits, this.#budget);
+    if (fragment.root.children.length !== 1 || fragment.root.children[0].namespace !== paragraph.namespace || fragment.root.children[0].localName !== "p" || fragment.root.content.some((node) => node.kind !== "element")) unsupported();
+    let path;
+    let parent;
+    const locate = (node, current) => {
+      this.#budget.charge("work", 1);
+      for (const [index, child] of node.children.entries()) {
+        this.#budget.charge("retainedBytes", (current.length + 1) * 8);
+        if (child === paragraph) {
+          path = [...current, index];
+          parent = node;
+          return;
+        }
+        locate(child, [...current, index]);
+        if (path) return;
+      }
+    };
+    locate(this.root, []);
+    if (!path || !parent) unsupported();
+    this.#stageInsertion(parent, xml2, paragraph, true);
+    return path;
+  }
+  /** Insert beside an editable native anchor without rewriting its MCE carrier. */
+  [insertParagraphAfter](paragraph, xml2, path) {
+    if (typeof xml2 !== "string") throw new InputTypeError("Expected XML markup.");
+    this.#assertOwnedElement(paragraph);
+    if (!this.#dialect || paragraph.namespace !== documentDialects[this.#dialect].w || paragraph.localName !== "p" || !this.#canEdit(paragraph) || !path.length) unsupported();
+    this.assertShapeEditAllowed(paragraph);
+    const fragment = parseDocumentXml(new TextEncoder().encode(`<root>${xml2}</root>`), this.#limits, this.#budget);
+    if (fragment.root.children.length !== 1 || fragment.root.children[0].namespace !== paragraph.namespace || fragment.root.children[0].localName !== "p" || fragment.root.content.some((node) => node.kind !== "element")) unsupported();
+    let parent = this.root;
+    for (const index2 of path.slice(0, -1)) {
+      this.#budget.charge("work", 1);
+      if (!Number.isSafeInteger(index2) || index2 < 0 || !parent.children[index2]) unsupported();
+      parent = parent.children[index2];
+    }
+    const index = path.at(-1);
+    if (!Number.isSafeInteger(index) || index < 0 || parent.children[index] !== paragraph) unsupported();
+    this.#stageInsertion(parent, xml2, parent.children[index + 1], true);
+    return [...path.slice(0, -1), index + 1];
+  }
+  /** Insert a typed row while retaining the physical boundary's original carrier. */
+  [insertTableRowXml](row, xml2, before) {
+    this.#assertOwnedElement(row);
+    if (typeof xml2 !== "string" || !this.#dialect || row.namespace !== documentDialects[this.#dialect].w || row.localName !== "tr" || !this.#canEdit(row)) unsupported();
+    this.assertShapeEditAllowed(row);
+    const fragment = parseDocumentXml(new TextEncoder().encode(`<root>${xml2}</root>`), this.#limits, this.#budget);
+    if (fragment.root.children.length !== 1 || fragment.root.children[0].namespace !== row.namespace || fragment.root.children[0].localName !== "tr" || fragment.root.content.some((item) => item.kind !== "element")) unsupported();
+    const pending = [this.root];
+    while (pending.length) {
+      const parent = pending.pop();
+      this.#budget.charge("work", 1 + parent.children.length);
+      const index = parent.children.indexOf(row);
+      if (index >= 0) {
+        this.#stageInsertion(parent, xml2, before ? row : parent.children[index + 1], true);
+        return;
+      }
+      for (const child of parent.children) pending.push(child);
+    }
+    unsupported();
+  }
+  [removeTableRowXml](table, row, markup) {
+    this.#assertOwnedElement(table);
+    this.#assertOwnedElement(row);
+    if (typeof markup !== "string" || !this.#dialect || table.namespace !== documentDialects[this.#dialect].w || table.localName !== "tbl" || row.namespace !== table.namespace || row.localName !== "tr" || !this.#canEdit(table) || !this.#canEdit(row) || this.#patches.has(table)) unsupported();
+    this.assertShapeEditAllowed(table);
+    const containers = new Set(this.compatibility[compatibilityContainers]), pending = [row];
+    while (pending.length) {
+      const node = pending.pop();
+      this.#budget.charge("work", 1 + node.attributes.length);
+      if (!containers.has(node) && (!this.#canEdit(node) || node.attributes.some((a) => !["http://www.w3.org/2000/xmlns/", "http://www.w3.org/XML/1998/namespace"].includes(a.namespace) && !this.#canEdit(a)))) unsupported();
+      for (const child of node.children) pending.push(child);
+    }
+    const expected = parseDocumentXml(new TextEncoder().encode(this.sourceXml(this.root, /* @__PURE__ */ new Map([[row, ""]]))), this.#limits, this.#budget);
+    const candidate = parseDocumentXml(new TextEncoder().encode(this.sourceXml(this.root, /* @__PURE__ */ new Map([[table, markup]]))), this.#limits, this.#budget);
+    if (opaqueXmlContent(expected.root, this.#budget, this.#profile) !== opaqueXmlContent(candidate.root, this.#budget, this.#profile)) unsupported();
+    this.#stageReplacement(table, markup, false, true);
+  }
+  /** Inserts admitted markup at an owned child boundary, retaining source tokens. */
+  insertChildren(parent, xml2, before) {
+    if (typeof xml2 !== "string") throw new InputTypeError("Expected XML markup.");
+    this.#assertOwnedElement(parent);
+    if (before !== void 0) this.#assertOwnedElement(before);
+    if (before && !parent.children.includes(before)) unsupported();
+    if (this.#guardCompatibility && !this.#canEdit(parent)) unsupported();
+    this.assertShapeEditAllowed(parent);
+    this.#stageInsertion(parent, xml2, before, true);
+  }
+  #stageInsertion(parent, xml2, before, checkMath = false) {
+    const span = this.#spans.get(parent);
+    const offset = before ? this.#spans.get(before).start : span.contentEnd;
+    const prefix = this.#source.slice(span.start, offset);
+    const suffix = this.#source.slice(offset, span.end);
+    const patch = span.empty ? prefix + ">" + xml2 + `</${parent.name}>` : prefix + xml2 + suffix;
+    this.#budget.charge("retainedBytes", patch.length * 8);
+    this.#budget.charge("work", patch.length * 4);
+    if (this.#patches.has(parent)) unsupported();
+    this.#patches.set(parent, patch);
+    try {
+      const serialized = this.serialize();
+      if (this.#dialect && this.root.localName === "styles" || this.#budget[documentXmlCache].immutableRoots?.has(this.root)) {
+        const cache = this.#budget[documentXmlCache];
+        cache.staged ??= /* @__PURE__ */ new WeakSet();
+        cache.staged.add(serialized);
+      }
+      const candidate = parseDocumentXml(serialized, this.#limits, this.#budget);
+      if (this.#dialect) validateXmlDialect(candidate.root, this.#dialect, this.#profile, this.#budget);
+      const inserted = parseDocumentXml(new TextEncoder().encode(`<root>${xml2}</root>`), this.#limits, this.#budget);
+      if (checkMath && containsMath(inserted.root, this.#budget)) unsupported();
+      const count = (node) => node.kind === "element" ? 1 + node.content.reduce((n, child) => n + count(child), 0) : 1;
+      this.#budget.charge("insertedNodes", inserted.root.content.reduce((n, node) => n + count(node), 0));
+    } catch (error) {
+      this.#patches.delete(parent);
+      throw error;
+    }
+  }
+  setText(node, text) {
+    if (typeof text !== "string") throw new InputTypeError("Expected an XML text string.");
+    if (!node || typeof node !== "object" || !["element", "text", "cdata", "comment", "processing-instruction"].includes(node.kind)) throw new InputTypeError("Expected an XML content node.");
+    if (!this.#spans.has(node)) throw new OwnershipError("Expected content owned by this XML editor.");
+    if (node.kind === "element") unsupported();
+    if (node.kind !== "text" && text.includes("\r")) unsupported();
+    if (node.kind === "cdata" && text.includes("]]>")) unsupported();
+    if (node.kind === "comment" && (text.includes("--") || text.endsWith("-"))) unsupported();
+    if (node.kind === "processing-instruction" && (text.includes("?>") || text.length && " 	\n".includes(text[0]))) unsupported();
+    this.#stage(node, text, node.text, node.kind === "text");
+  }
+  setAttribute(element, name, value) {
+    if (typeof name !== "string" && (!name || typeof name !== "object" || Array.isArray(name) || typeof name.namespace !== "string" || typeof name.localName !== "string" || Object.keys(name).some((key) => key !== "namespace" && key !== "localName")) || typeof value !== "string")
+      throw new InputTypeError("Expected an XML attribute name or expanded name and string value.");
+    this.#assertOwnedElement(element);
+    const attribute = element.attributes.find((item) => typeof name === "string" ? item.name === name : item.namespace === name.namespace && item.localName === name.localName);
+    if (!attribute || attribute.namespace === "http://www.w3.org/2000/xmlns/") unsupported();
+    this.#stage(attribute, value, attribute.value, true);
+  }
+  /** Leading scalar XML text, retaining every child and non-text token. */
+  setLeadingText(element, value) {
+    this.#assertOwnedEdit(element);
+    const leading = [];
+    for (const token of element.content) {
+      if (token.kind !== "text" && token.kind !== "cdata") break;
+      leading.push(token);
+    }
+    if (this.#guardCompatibility && leading.some((token) => !this.#canEdit(token))) unsupported();
+    const span = this.#spans.get(element);
+    const end = leading.length ? this.#spans.get(leading.at(-1)).end + (leading.at(-1).kind === "cdata" ? 3 : 0) : span.contentStart;
+    const patch = this.#source.slice(span.start, span.contentStart) + (span.empty ? ">" : "") + escapeValue(value ?? "", false) + (span.empty ? `</${element.name}>` : this.#source.slice(end, span.end));
+    this.#acceptOwnedPatch(element, patch, value ? 1 : 0);
+  }
+  /** Tail text is owned by the containing element, never by an external resource. */
+  setElementTail(element, value) {
+    this.#assertOwnedElement(element);
+    const parent = [...this.#elements].find((node) => node.children.includes(element));
+    const owner = parent ?? element;
+    this.#assertOwnedEdit(owner);
+    const content = parent?.content ?? this.root.epilog ?? [];
+    const index = parent ? content.indexOf(element) + 1 : 0;
+    let end = this.#spans.get(element).end;
+    for (let offset = index; offset < content.length; offset++) {
+      const token = content[offset];
+      if (token.kind !== "text" && token.kind !== "cdata") break;
+      if (parent && this.#guardCompatibility && !this.#canEdit(token)) unsupported();
+      end = this.#spans.get(token).end + (token.kind === "cdata" ? 3 : 0);
+    }
+    if (!parent) {
+      if (end !== this.#spans.get(element).end) {
+        let first = true;
+        for (const token of content) {
+          if (token.kind !== "text") break;
+          this.setText(token, first ? value ?? "" : "");
+          first = false;
+        }
+        return;
+      }
+      if (!value) return;
+      this.#acceptOwnedPatch(element, this.sourceXml(element) + escapeValue(value ?? "", false), value ? 1 : 0);
+      return;
+    }
+    const span = this.#spans.get(parent);
+    const start = this.#spans.get(element).end;
+    this.#acceptOwnedPatch(parent, this.#source.slice(span.start, start) + escapeValue(value ?? "", false) + this.#source.slice(end, span.end), value ? 1 : 0);
+  }
+  /** Native frame dimensions may edit an active branch with empty alternatives. */
+  [editInlineShapeExtentXml](inline, extent, axis, value) {
+    this.#assertOwnedElement(inline);
+    this.#assertOwnedElement(extent);
+    if (!this.#dialect || this.#patches.size || !Number.isSafeInteger(value) || value < 0 || !["cx", "cy"].includes(axis)) unsupported();
+    const ns = documentDialects[this.#dialect], children = activeXmlChildren(this, this.#budget);
+    if (inline.namespace !== ns.wp || inline.localName !== "inline" || extent.children.length) unsupported();
+    const frames = children(inline).filter((node) => node.namespace === ns.wp && node.localName === "extent");
+    if (frames.length !== 1) unsupported();
+    const transforms = [];
+    const visit = (node) => {
+      this.#budget.charge("work", 1);
+      if (!this.#profile.understoodNamespaces.includes(node.namespace) || node.localName === "extLst") unsupported();
+      if (node.namespace === ns.a && node.localName === "xfrm") transforms.push(...children(node).filter((child) => child.namespace === ns.a && child.localName === "ext"));
+      for (const child of children(node)) visit(child);
+    };
+    if (extent !== frames[0] && (extent.namespace !== ns.a || extent.localName !== "ext")) unsupported();
+    this.assertShapeEditAllowed(inline);
+    if (this.#canEdit(extent)) {
+      this.setQualifiedAttribute(extent, { namespace: "", localName: axis }, String(value));
+      return;
+    }
+    visit(inline);
+    if (transforms.length > 1 || extent !== frames[0] && transforms[0] !== extent) unsupported();
+    const ownerSpan = this.#spans.get(inline), extentSpan = this.#spans.get(extent);
+    let alternatives = 0;
+    for (const branch of this.compatibility.branches) {
+      this.#budget.charge("work", 1 + branch.alternateContent.children.length);
+      const span = this.#spans.get(branch.alternateContent);
+      if (!(span.start <= ownerSpan.start && ownerSpan.end <= span.end || ownerSpan.start <= span.start && span.end <= ownerSpan.end || span.start <= extentSpan.start && extentSpan.end <= span.end)) continue;
+      alternatives++;
+      if (!branch.selected || branch.alternateContent.children.some((node) => node !== branch.selected && node.children.length)) unsupported();
+    }
+    if (!alternatives) unsupported();
+    for (const node of this.#elements) {
+      this.#budget.charge("work", 1);
+      const span = this.#spans.get(node);
+      if (span.start > ownerSpan.start || ownerSpan.end > span.end) continue;
+      if (node.namespace === mathNamespace(false) || node.namespace === mathNamespace(true) || node.namespace === ns.a && ["ext", "extLst"].includes(node.localName) || node.namespace === ns.w && ["pict", "object"].includes(node.localName)) unsupported();
+    }
+    const attributes = extent.attributes.filter((attribute) => attribute.namespace === "" && attribute.localName === axis);
+    if (attributes.length !== 1) unsupported();
+    const attributeSpan = this.#spans.get(attributes[0]);
+    this.#stageReplacement(extent, this.#source.slice(extentSpan.start, attributeSpan.start) + String(value) + this.#source.slice(attributeSpan.end, extentSpan.end));
+  }
+  /** Qualified attribute insertion/removal preserves unrelated lexical shells. */
+  setQualifiedAttribute(element, name, value) {
+    this.#assertOwnedEdit(element);
+    if (name.namespace === "http://www.w3.org/2000/xmlns/" || name.localName === "xmlns") unsupported();
+    const existing = element.attributes.find((attribute) => attribute.namespace === name.namespace && attribute.localName === name.localName);
+    const understood = this.#profile.understoodNamespaces.includes(name.namespace) || this.#profile.understoodElements?.some((node) => node.namespace === element.namespace && node.localName === element.localName && node.attributes.some((attribute) => attribute.namespace === name.namespace && attribute.localName === name.localName));
+    if (existing && this.#guardCompatibility && !this.#canEdit(existing)) unsupported();
+    if (!existing && this.#guardCompatibility && !understood) unsupported();
+    if (!existing && value === null) return;
+    if (existing && value !== null) {
+      this.setAttribute(element, name, value);
+      return;
+    }
+    if (existing?.value === value) return;
+    const span = this.#spans.get(element);
+    let patch;
+    if (existing) {
+      const attribute = this.#spans.get(existing);
+      patch = value === null ? this.#source.slice(span.start, attribute.attributeStart) + this.#source.slice(attribute.attributeEnd, span.end) : this.#source.slice(span.start, attribute.start) + escapeValue(value, true) + this.#source.slice(attribute.end, span.end);
+    } else {
+      let prefix = "", declaration = "";
+      if (name.namespace) {
+        prefix = [...element.namespaces].find(([prefix2, namespace]) => prefix2 && namespace === name.namespace)?.[0] ?? "xv";
+        if (!element.namespaces.has(prefix)) declaration = ` xmlns:${prefix}="${escapeValue(name.namespace, true)}"`;
+        else if (element.namespaces.get(prefix) !== name.namespace) {
+          while (element.namespaces.has(prefix)) prefix += "v";
+          declaration = ` xmlns:${prefix}="${escapeValue(name.namespace, true)}"`;
+        }
+      }
+      const offset = span.empty ? span.contentStart : span.contentStart - 1;
+      patch = this.#source.slice(span.start, offset) + declaration + ` ${prefix ? prefix + ":" : ""}${name.localName}="${escapeValue(value, true)}"` + this.#source.slice(offset, span.end);
+    }
+    this.#acceptOwnedPatch(element, patch, existing ? 0 : 1);
+  }
+  #assertOwnedElement(element) {
+    if (!element || typeof element !== "object" || element.kind !== "element") throw new InputTypeError("Expected an XML element.");
+    if (!this.#elements.has(element)) throw new OwnershipError("Expected an element owned by this XML editor.");
+  }
+  #assertOwnedEdit(element) {
+    this.#assertOwnedElement(element);
+    if (this.#patches.size || this.#guardCompatibility && !this.#canEdit(element)) unsupported();
+    this.assertShapeEditAllowed(element);
+  }
+  #acceptOwnedPatch(element, patch, inserted) {
+    this.#budget.charge("work", patch.length * 4);
+    this.#budget.charge("retainedBytes", patch.length * 8);
+    this.#patches.set(element, patch);
+    try {
+      const serialized = this.serialize();
+      if (this.#dialect && this.root.localName === "styles") {
+        const cache = this.#budget[documentXmlCache];
+        cache.staged ??= /* @__PURE__ */ new WeakSet();
+        cache.staged.add(serialized);
+      }
+      const candidate = parseDocumentXml(serialized, this.#limits, this.#budget);
+      if (this.#dialect) validateXmlDialect(candidate.root, this.#dialect, this.#profile, this.#budget);
+      this.#budget.charge("insertedNodes", inserted);
+    } catch (error) {
+      this.#patches.delete(element);
+      throw error;
+    }
+  }
+  #stage(token, value, original, escape) {
+    if (value.length > (this.#limits.maxBytes ?? Infinity))
+      throw new ResourceLimitError("XML output byte limit exceeded.");
+    this.#budget.charge("work", value.length * 8);
+    this.#budget.charge("retainedBytes", value.length * 12);
+    for (const char of value) {
+      const point = char.codePointAt(0);
+      if (!(point === 9 || point === 10 || point === 13 || point >= 32 && point <= 55295 || point >= 57344 && point <= 65533 || point >= 65536 && point <= 1114111))
+        throw new InvalidXmlError("Invalid XML character in replacement value.");
+    }
+    if (value !== original && this.#guardCompatibility && !this.#canEdit(token) && !("kind" in token && token.kind === "text" && this.root.epilog?.includes(token))) unsupported();
+    const owner = this.#spans.get(token).owner;
+    const element = owner.kind === "element" ? owner : [...this.#elements].find((n) => n.content.includes(owner));
+    if (element) this.assertShapeEditAllowed(element);
+    const before = new Map(this.#patches);
+    if (value === original) this.#patches.delete(token);
+    else {
+      let patch = escape ? escapeValue(value, !("kind" in token)) : value;
+      if ("kind" in token && token.kind === "processing-instruction" && value && !" 	\r\n".includes(this.#source[this.#spans.get(token).start - 1])) patch = " " + patch;
+      this.#patches.set(token, patch);
+    }
+    try {
+      const candidate = parseDocumentXml(this.serialize(), this.#limits, this.#budget);
+      if (this.#dialect && this.#patches.size) validateXmlDialect(candidate.root, this.#dialect, this.#profile, this.#budget);
+    } catch (error) {
+      this.#patches.clear();
+      for (const [key, patch] of before) this.#patches.set(key, patch);
+      throw error;
+    }
+  }
+  serialize() {
+    for (const [current, original] of this.#namespaces) {
+      if (current.size !== original.size) unsupported();
+      for (const [prefix, uri] of original) if (current.get(prefix) !== uri) unsupported();
+    }
+    if (!this.#patches.size) {
+      this.#budget.charge("work", this.#document.bytes.length);
+      this.#budget.charge("retainedBytes", this.#document.bytes.length);
+      return new Uint8Array(this.#document.bytes);
+    }
+    const patches = [...this.#patches].map(([token, value]) => ({ ...this.#spans.get(token), value }));
+    patches.sort((a, b) => a.start - b.start);
+    const maxBytes = this.#limits.maxBytes ?? Infinity;
+    let length = this.#source.length;
+    for (const patch of patches) length += patch.value.length - (patch.end - patch.start);
+    const utf8 = this.#document.encoding === "UTF-8";
+    if (length * (utf8 ? 1 : 2) > maxBytes)
+      throw new ResourceLimitError("XML output byte limit exceeded.");
+    this.#budget.charge("retainedBytes", length * 8);
+    this.#budget.charge("work", length * 4);
+    const chunks = [];
+    let offset = 0;
+    for (const patch of patches) {
+      if (patch.start < offset) unsupported();
+      chunks.push(this.#source.slice(offset, patch.start), patch.value);
+      offset = patch.end;
+    }
+    chunks.push(this.#source.slice(offset));
+    const source = chunks.join("");
+    let bytes;
+    if (utf8) bytes = new TextEncoder().encode(source);
+    else {
+      bytes = new Uint8Array(source.length * 2);
+      const view = new DataView(bytes.buffer);
+      for (let index = 0; index < source.length; index++)
+        view.setUint16(index * 2, source.charCodeAt(index), this.#document.encoding === "UTF-16LE");
+    }
+    if (bytes.length > maxBytes) throw new ResourceLimitError("XML output byte limit exceeded.");
+    return bytes;
+  }
+};
+
+// packages/safe-bash-docx-engine/src/equation-fragments.ts
+var xml = "http://www.w3.org/XML/1998/namespace";
+var xmlns2 = "http://www.w3.org/2000/xmlns/";
+var mathNamespace = (strict) => strict ? "http://purl.oclc.org/ooxml/officeDocument/math" : "http://schemas.openxmlformats.org/officeDocument/2006/math";
+var expressions = ["r", "f", "m", "sSub"];
+function normalized(value) {
+  let start = 0, end = value.length;
+  while (start < end && " 	\r\n".includes(value[start])) start++;
+  while (end > start && " 	\r\n".includes(value[end - 1])) end--;
+  return value.slice(start, end);
+}
+var leaves = { type: { attribute: "val", required: true, values: ["bar", "skw", "lin", "noBar"] }, argSz: { attribute: "val", required: true, min: -2, max: 2 }, jc: { attribute: "val", values: ["left", "right", "center", "centerGroup"] }, scr: { attribute: "val", values: ["roman", "script", "fraktur", "double-struck", "sans-serif", "monospace"] }, sty: { attribute: "val", values: ["p", "b", "i", "bi"] }, lit: { attribute: "val", values: ["true", "false", "1", "0", "on", "off"] }, nor: { attribute: "val", values: ["true", "false", "1", "0", "on", "off"] }, aln: { attribute: "val", values: ["true", "false", "1", "0", "on", "off"] }, brk: { attribute: "alnAt", min: 1, max: 255 } };
+function integer(value, min, max) {
+  const s = normalized(value);
+  let i = s[0] === "+" || s[0] === "-" ? 1 : 0;
+  if (i === s.length) return false;
+  for (; i < s.length; i++) if (!"0123456789".includes(s[i])) return false;
+  const n = Number(s);
+  return Number.isSafeInteger(n) && n >= min && n <= max;
+}
+function inspectEquationFragment(root, namespace, budget, part = "", base = []) {
+  const issues = [];
+  const issue = (path) => {
+    budget.charge("diagnosticBytes", 160 + part.length + path.length * 8);
+    budget.charge("retainedBytes", 256 + path.length * 8);
+    issues.push({ code: "opaque-equation-fragment", part, path: [...path], message: "Stored math is outside the bounded equation fragment grammar." });
+  };
+  const visit = (node, path) => {
+    budget.charge("work", 1 + node.attributes.length + node.content.length);
+    let valid = node.namespace === namespace;
+    const names = node.children.map((n) => n.localName), optional = (property, allowed, minimum = 0) => {
+      const offset = names[0] === property ? 1 : 0;
+      return names.length - offset >= minimum && names.slice(offset).every((n) => allowed.includes(n));
+    }, exact = (property, children) => {
+      const offset = names[0] === property ? 1 : 0;
+      return names.slice(offset).length === children.length && children.every((n, i) => names[i + offset] === n);
+    };
+    if (node.localName === "oMath") valid &&= names.every((n) => expressions.includes(n));
+    else if (node.localName === "oMathPara") valid &&= optional("oMathParaPr", ["oMath"], 1);
+    else if (node.localName === "r") valid &&= optional("rPr", ["t"]);
+    else if (node.localName === "f") valid &&= exact("fPr", ["num", "den"]);
+    else if (node.localName === "m") valid &&= optional("mPr", ["mr"], 1);
+    else if (node.localName === "mr") valid &&= names.length > 0 && names.every((n) => n === "e");
+    else if (node.localName === "sSub") valid &&= exact("sSubPr", ["e", "sub"]);
+    else if (["num", "den", "e", "sub"].includes(node.localName)) valid &&= optional("argPr", expressions);
+    else if (["mPr", "sSubPr", "t"].includes(node.localName)) valid &&= names.length === 0;
+    else if (["argPr", "fPr", "oMathParaPr"].includes(node.localName)) {
+      const child = { argPr: "argSz", fPr: "type", oMathParaPr: "jc" }[node.localName];
+      valid &&= names.length <= 1 && names.every((n) => n === child);
+    } else if (node.localName === "rPr") {
+      const order3 = ["lit", "nor", "scr", "sty", "brk", "aln"];
+      let previous = -1;
+      valid &&= !names.includes("nor") || !names.some((n) => ["scr", "sty"].includes(n));
+      for (const n of names) {
+        const index = order3.indexOf(n);
+        if (index <= previous) valid = false;
+        previous = index;
+      }
+    } else if (leaves[node.localName]) valid &&= names.length === 0;
+    else valid = false;
+    for (const content of node.content) {
+      if (content.kind === "element") continue;
+      if (content.kind !== "text" && content.kind !== "cdata") valid = false;
+      else if (node.localName !== "t" && normalized(content.text)) valid = false;
+    }
+    for (const attribute of node.attributes) {
+      budget.charge("work", attribute.value.length);
+      if (attribute.namespace === xmlns2) {
+        if (attribute.value !== namespace && attribute.value !== xml) valid = false;
+        continue;
+      }
+      if (node.localName === "t" && attribute.namespace === xml && attribute.localName === "space" && ["default", "preserve"].includes(attribute.value)) continue;
+      const leaf2 = leaves[node.localName];
+      if (!leaf2 || attribute.namespace !== namespace || attribute.localName !== leaf2.attribute) valid = false;
+      else if (leaf2.values) {
+        const value = ["lit", "nor", "aln"].includes(node.localName) ? normalized(attribute.value) : attribute.value;
+        if (!leaf2.values.includes(value) || namespace === mathNamespace(true) && ["on", "off"].includes(value)) valid = false;
+      } else if (!integer(attribute.value, leaf2.min, leaf2.max)) valid = false;
+    }
+    const leaf = leaves[node.localName];
+    if (leaf?.required && !node.attributes.some((a) => a.namespace === namespace && a.localName === leaf.attribute)) valid = false;
+    if (!valid) issue(path);
+    node.children.forEach((child, i) => visit(child, [...path, i]));
+  };
+  if (root.namespace !== namespace || !["oMath", "oMathPara"].includes(root.localName)) issue(base);
+  visit(root, base);
+  return issues;
+}
+function admitEquationFragment(bytes, namespace, budget) {
+  const parsed = parseDocumentXml(bytes, {}, budget), root = parsed.root;
+  const framing = [...root.prolog ?? [], ...root.epilog ?? []];
+  if (framing.some((n) => n.kind !== "text" && !(n.kind === "processing-instruction" && "target" in n && n.target === "xml") || n.kind === "text" && normalized(n.text)) || inspectEquationFragment(root, namespace, budget).length) throw new UnsupportedEditError("Equation fragment is outside the bounded grammar.");
+  const editor = new DocumentXmlEditor(bytes, {}, void 0, budget);
+  return { root, xml: editor.sourceXml(editor.root) };
+}
+
+export {
+  storedMeasure,
+  activeXmlChildren,
+  displayXml,
+  opaqueXmlContent,
+  mathNamespace,
+  inspectEquationFragment,
+  admitEquationFragment,
+  revisionInfo,
+  containsRevision,
+  assertOutsideRevisionRanges,
+  containsActiveTableHistory,
+  assertFormattingHistoryEditable,
+  paragraphTextHistory,
+  collectShapeCarriers,
+  UnsupportedEditError,
+  replaceListPropertyXml,
+  replaceCommentRangeXml,
+  replaceNativeTabCollectionXml,
+  sourceRootEnvelope,
+  appendBodyBlocks,
+  insertParagraphBefore,
+  insertParagraphAfter,
+  insertTableRowXml,
+  removeTableRowXml,
+  removeNoteBodyXml,
+  replaceActiveStyleXml,
+  insertActiveLatentStyles,
+  editActiveRelationshipXml,
+  editActivePropertyXml,
+  replaceSplitTextRunXml,
+  splitNativeTextRunXml,
+  nativeElementSourceTokens,
+  nativeXmlTriviaSource,
+  nativeScalarTextSource,
+  replaceSplitParagraphXml,
+  copiedSplitParagraphProperties,
+  editInlineShapeExtentXml,
+  DocumentXmlEditor,
+  underline,
+  highlights,
+  themes,
+  runElementOpen,
+  formattedRunProperties,
+  equivalentRunKey,
+  styleChild,
+  styleAttribute,
+  styleIds,
+  styleToggle,
+  styleInteger,
+  readStyleProperties,
+  inheritStyleProperties,
+  mergeStyleChildren,
+  styleDisplayName,
+  styleStoredName,
+  selectNamedStyles,
+  xmlValue,
+  twips,
+  pageGeometry,
+  renderContent,
+  renderTheme,
+  paragraphUnits,
+  alignments,
+  tabAlignmentXml,
+  paragraphLineMultiples,
+  newTabStopXml,
+  paragraphProperties
+};