@poe-platform/safe-bash 0.1.806 → 0.1.807

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

@@ -0,0 +1,288 @@
+import {
+  assertOutsideFields,
+  parseFields
+} from "./chunk-6EHVFKM7.js";
+import {
+  DocumentPackage
+} from "./chunk-GLPIFP7N.js";
+import {
+  UnsupportedEditError,
+  activeXmlChildren,
+  assertOutsideRevisionRanges,
+  containsRevision,
+  replaceSplitTextRunXml,
+  revisionInfo,
+  splitNativeTextRunXml,
+  xmlValue
+} from "./chunk-YPVBU7QF.js";
+import {
+  normalizePropertyDate,
+  parseStoredDateTime,
+  storedIntegerIdentity
+} from "./chunk-VEUQWV2V.js";
+import {
+  compatibilityContainers
+} from "./chunk-GZ2N24A2.js";
+import {
+  isXmlContentType,
+  parseDocumentXml
+} from "./chunk-MWAAMNAM.js";
+
+// packages/safe-bash-docx-engine/src/tracked-text.ts
+function opening(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 !== "http://www.w3.org/2000/xmlns/").map((a) => ` ${a.name}="${xmlValue(a.value)}"`).join("")}>`;
+}
+function runProperties(node, xml, budget, formatting) {
+  const w = node.namespace;
+  const active = activeXmlChildren(xml, budget);
+  const props = active(node).find((child) => child.namespace === w && child.localName === "rPr");
+  let properties = props ? xml.sourceXml(props) : "";
+  if (formatting && (formatting.bold !== void 0 || formatting.italic !== void 0)) {
+    const removed = new Map(props ? active(props).filter((child) => child.namespace === w && (child.localName === "b" && formatting.bold !== void 0 || child.localName === "i" && formatting.italic !== void 0)).map((child) => [child, ""]) : []);
+    properties = `<rt:rPr xmlns:rt="${xmlValue(w)}">${props ? xml.sourceXml(props, removed, true) : ""}${formatting.bold === void 0 ? "" : `<rt:b rt:val="${Number(formatting.bold)}"/>`}${formatting.italic === void 0 ? "" : `<rt:i rt:val="${Number(formatting.italic)}"/>`}</rt:rPr>`;
+  }
+  return properties;
+}
+function runTextContent(w, text, deleted) {
+  let content = "", pending = "";
+  const flush = () => {
+    if (pending) content += `<rt:${deleted ? "delText" : "t"} xmlns:rt="${xmlValue(w)}" xml:space="preserve">${xmlValue(pending)}</rt:${deleted ? "delText" : "t"}>`;
+    pending = "";
+  };
+  for (const char of text) {
+    if (char === "	" || char === "\n") {
+      flush();
+      content += `<rt:${char === "	" ? "tab" : "br"} xmlns:rt="${xmlValue(w)}"/>`;
+    } else pending += char;
+  }
+  flush();
+  return content;
+}
+function textRun(node, text, xml, budget, deleted, formatting) {
+  return opening(node) + runProperties(node, xml, budget, formatting) + runTextContent(node.namespace, text, deleted) + `</${node.name}>`;
+}
+function stageTrackedText(editor, edits, metadata, budget, limits) {
+  xmlValue(metadata.author);
+  const timestamp = normalizePropertyDate(metadata.timestamp);
+  parseStoredDateTime(timestamp, "xsd");
+  const used = /* @__PURE__ */ new Set();
+  for (const part of new DocumentPackage(editor.snapshot(), limits, budget).parts) {
+    if (!isXmlContentType(part.content_type)) continue;
+    budget.charge("retainedBytes", 8);
+    const pending = [parseDocumentXml(part.bytes, {}, budget).root];
+    while (pending.length) {
+      const node = pending.pop();
+      budget.charge("work", 1);
+      const info = revisionInfo(node);
+      const identity = storedIntegerIdentity(info?.id ?? void 0);
+      if (identity !== void 0) {
+        const id = Number(identity);
+        if (Number.isSafeInteger(id)) used.add(id);
+      }
+      budget.charge("retainedBytes", node.children.length * 8);
+      for (let index = node.children.length - 1; index >= 0; index--) pending.push(node.children[index]);
+    }
+  }
+  let next = 1;
+  const wrap = (kind, run, w) => {
+    while (used.has(next)) {
+      budget.charge("work", 1);
+      next++;
+    }
+    budget.check("work", 1);
+    used.add(next);
+    return `<rt:${kind} xmlns:rt="${xmlValue(w)}" rt:id="${next++}" rt:author="${xmlValue(metadata.author)}" rt:date="${timestamp}">${run}</rt:${kind}>`;
+  };
+  const groups = /* @__PURE__ */ new Map();
+  for (const edit of edits) {
+    const group = groups.get(edit.paragraph.token) ?? [];
+    group.push(edit);
+    groups.set(edit.paragraph.token, group);
+  }
+  const staged = [];
+  for (const group of groups.values()) {
+    const location = group[0].paragraph;
+    const xml = editor.xml(location.value.part.slice(1));
+    let paragraph = xml.root;
+    const ancestors = [paragraph];
+    for (const i of location.value.path) {
+      paragraph = paragraph.children[i];
+      ancestors.push(paragraph);
+    }
+    const w = paragraph.namespace;
+    const active = activeXmlChildren(xml, budget);
+    if (paragraph.localName !== "p" || ancestors.some((node) => revisionInfo(node) || ["sdt", "fldSimple", "hyperlink", "customXml"].includes(node.localName)) || ancestors.some((node) => active(node).some((child) => child.namespace === w && ["pPr", "trPr", "tblPr", "tcPr", "sectPr"].includes(child.localName) && containsRevision(child, budget))))
+      throw new UnsupportedEditError("Tracked text cannot change existing review or controlled content.");
+    const paragraphChildren = active(paragraph);
+    const targets = new Set(paragraphChildren), containers = new Set(xml.compatibility[compatibilityContainers]);
+    const runPaths = /* @__PURE__ */ new Map();
+    const path = [];
+    budget.charge("retainedBytes", 32);
+    const traversal = [{ node: paragraph, index: 0 }];
+    while (traversal.length) {
+      const frame = traversal.at(-1), index = frame.index++, child = frame.node.children[index];
+      budget.charge("work", 1);
+      if (!child) {
+        traversal.pop();
+        if (traversal.length) path.pop();
+        continue;
+      }
+      if (targets.has(child)) {
+        budget.charge("retainedBytes", 48 + (location.value.path.length + path.length + 1) * 8);
+        runPaths.set(child, [...location.value.path, ...path, index]);
+      } else if (containers.has(child)) {
+        budget.charge("retainedBytes", 40);
+        path.push(index);
+        traversal.push({ node: child, index: 0 });
+      }
+    }
+    const runs = [];
+    const barriers = [];
+    let offset = 0;
+    const opaqueLength = (node) => {
+      budget.charge("retainedBytes", 8);
+      const pending = [node];
+      let length = 0;
+      while (pending.length) {
+        const current = pending.pop();
+        budget.charge("work", 1);
+        const info = revisionInfo(current);
+        if (info?.support === "opaque" || info?.type === "delete" || info?.markup.startsWith("moveFrom") || ["rPr", "pPr", "instrText", "delInstrText", "drawing", "pict", "object"].includes(current.localName)) continue;
+        if (current.namespace !== w) continue;
+        if (current.localName === "t") {
+          length += [...current.text].length;
+          continue;
+        }
+        if (["tab", "ptab", "br", "cr", "noBreakHyphen", "softHyphen"].includes(current.localName)) {
+          length++;
+          continue;
+        }
+        const children = active(current);
+        budget.charge("retainedBytes", children.length * 8);
+        for (let index = children.length - 1; index >= 0; index--) pending.push(children[index]);
+      }
+      return length;
+    };
+    for (const node of paragraphChildren) {
+      budget.charge("work", 1);
+      if (node.namespace === w && node.localName === "pPr") continue;
+      if (node.namespace !== w || node.localName !== "r") {
+        barriers.push(offset);
+        const length2 = opaqueLength(node);
+        if (length2) runs.push({ node, start: offset, end: offset + length2, text: "", unsafe: true });
+        offset += length2;
+        continue;
+      }
+      let unsafe = containsRevision(node, budget);
+      let text = "";
+      const runChildren = active(node);
+      for (const child of runChildren) {
+        if (child.namespace !== w || !["rPr", "t", "tab", "br", "cr"].includes(child.localName) || child.localName === "br" && child.attributes.some((a) => a.localName === "type" && !["textWrapping"].includes(a.value))) unsafe = true;
+        if (child.localName === "rPr") continue;
+        if (child.namespace === w) text += child.localName === "t" ? child.text : ["tab", "ptab"].includes(child.localName) ? "	" : ["br", "cr"].includes(child.localName) ? "\n" : ["noBreakHyphen", "softHyphen"].includes(child.localName) ? child.localName === "noBreakHyphen" ? "\u2011" : "\xAD" : "";
+      }
+      budget.charge("retainedBytes", text.length * 4);
+      const length = [...text].length;
+      runs.push({ node, text, start: offset, end: offset + length, unsafe, native: runChildren.some((child) => !node.children.includes(child)) });
+      offset += length;
+    }
+    const story = ancestors.map((node, depth) => ({ node, path: location.value.path.slice(0, depth) })).reverse().find((owner) => owner.node.namespace === w && ["body", "hdr", "ftr", "footnote", "endnote", "comment", "txbxContent"].includes(owner.node.localName));
+    if (!story) throw new UnsupportedEditError("Tracked text requires an admitted story owner.");
+    const fields = parseFields(story.node, story.path, budget, xml.compatibility.content);
+    group.sort((a, b) => a.start - b.start);
+    let last = -1;
+    const affected = /* @__PURE__ */ new Map();
+    for (const edit of group) {
+      if (!Number.isSafeInteger(edit.start) || !Number.isSafeInteger(edit.end) || edit.start < 0 || edit.end < edit.start || edit.end > offset || edit.start < last) throw new UnsupportedEditError("Tracked text ranges are unavailable or overlap.");
+      last = edit.end;
+      if (barriers.some((position) => edit.start < position && position < edit.end)) throw new UnsupportedEditError("Tracked text cannot cross annotation or opaque boundaries.");
+      const selected = runs.filter((run) => edit.start === edit.end ? run.start <= edit.start && edit.start <= run.end : run.start < edit.end && run.end > edit.start);
+      if (!selected.length) {
+        if (!offset && !runs.length && edit.start === 0) {
+          const synthetic = parseDocumentXml(new TextEncoder().encode(`<r xmlns="${xmlValue(w)}"/>`), {}, budget).root;
+          const run = { node: synthetic, text: "", start: 0, end: 0, synthetic: true };
+          selected.push(run);
+          runs.push(run);
+        } else throw new UnsupportedEditError("Tracked insertion has no ordinary run owner.");
+      }
+      if (edit.start === edit.end) selected.splice(1);
+      if (selected.some((run) => run.unsafe)) throw new UnsupportedEditError("Tracked text cannot change existing review or compound run content.");
+      const source = selected[0];
+      for (const run of selected) {
+        assertOutsideRevisionRanges(xml.root, run.synthetic ? paragraph : run.node, budget, xml.compatibility.branches);
+        assertOutsideFields(fields, run.synthetic ? location.value.path : runPaths.get(run.node));
+        const records = affected.get(run) ?? [];
+        records.push({ start: Math.max(edit.start, run.start) - run.start, end: Math.min(edit.end, run.end) - run.start, text: run === selected.at(-1) ? edit.text : "", source, edit });
+        affected.set(run, records);
+      }
+    }
+    const patches = /* @__PURE__ */ new Map();
+    for (const [run, records] of affected) {
+      if (run.native) {
+        const patch = { fragments: [], wrappers: [] };
+        const leaves = active(run.node).filter((child) => child.namespace === w && child.localName !== "rPr");
+        const append = (start, end, kind, inserted, source = run.node, formatting) => {
+          const content = /* @__PURE__ */ new Map();
+          if (inserted !== void 0) content.set(leaves[0], runTextContent(w, inserted, false));
+          else {
+            let offset2 = 0;
+            for (const leaf of leaves) {
+              const scalars2 = leaf.localName === "t" ? [...leaf.text] : [""];
+              const from = Math.max(0, start - offset2), to = Math.min(scalars2.length, end - offset2);
+              offset2 += scalars2.length;
+              if (from >= to) continue;
+              if (leaf.localName !== "t" || kind !== "del" && from === 0 && to === scalars2.length) content.set(leaf, xml.sourceXml(leaf));
+              else {
+                const prefix = leaf.name.includes(":") ? leaf.name.slice(0, leaf.name.indexOf(":") + 1) : "";
+                const name = kind === "del" ? prefix + "delText" : leaf.name;
+                const attributes = leaf.attributes.filter((attribute) => !(attribute.namespace === "http://www.w3.org/XML/1998/namespace" && attribute.localName === "space"));
+                content.set(leaf, opening({ ...leaf, name, attributes }).slice(0, -1) + ` xml:space="preserve">${xmlValue(scalars2.slice(from, to).join(""))}</${name}>`);
+              }
+            }
+          }
+          patch.fragments.push({ properties: runProperties(source, xml, budget, formatting), content });
+          patch.wrappers.push(kind ? wrap(kind, "", w) : null);
+        };
+        let position2 = 0;
+        for (const record of records) {
+          if (position2 < record.start) append(position2, record.start);
+          if (record.start < record.end) append(record.start, record.end, "del");
+          if (record.text) append(0, 0, "ins", record.text, record.source.node, record.edit);
+          position2 = record.end;
+        }
+        if (position2 < [...run.text].length) append(position2, [...run.text].length);
+        patches.set(run.node, patch);
+        continue;
+      }
+      const scalars = [...run.text];
+      let position = 0, markup = "";
+      for (const record of records) {
+        if (position < record.start) markup += textRun(run.node, scalars.slice(position, record.start).join(""), xml, budget, false);
+        if (record.start < record.end) markup += wrap("del", textRun(run.node, scalars.slice(record.start, record.end).join(""), xml, budget, true), w);
+        if (record.text) markup += wrap("ins", textRun(record.source.node, record.text, xml, budget, false, record.edit), w);
+        position = record.end;
+      }
+      if (position < scalars.length) markup += textRun(run.node, scalars.slice(position).join(""), xml, budget, false);
+      if (!run.synthetic) patches.set(run.node, markup);
+      else patches.set(paragraph, xml.sourceXml(paragraph, /* @__PURE__ */ new Map(), true) + markup);
+    }
+    staged.push({ xml, paragraph, patches });
+  }
+  for (const { xml, paragraph, patches } of staged) {
+    const paragraphPatch = patches.get(paragraph);
+    if (typeof paragraphPatch === "string") xml.replaceElement(paragraph, opening(paragraph) + paragraphPatch + `</${paragraph.name}>`);
+    else for (const [run, patch] of patches) {
+      if (typeof patch === "string") xml[replaceSplitTextRunXml](run, patch);
+      else xml[splitNativeTextRunXml](run, patch.fragments, true, (markup, index) => {
+        const wrapper = patch.wrappers[index];
+        if (!wrapper) return markup;
+        const openingEnd = wrapper.indexOf(">") + 1;
+        return wrapper.slice(0, openingEnd) + markup + wrapper.slice(openingEnd);
+      });
+    }
+  }
+}
+
+export {
+  stageTrackedText
+};

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

@@ -0,0 +1,316 @@
+import {
+  DocumentXmlEditor,
+  UnsupportedEditError
+} from "./chunk-YPVBU7QF.js";
+import {
+  commentExtensionParts,
+  dialectForNamespace,
+  documentDialects
+} from "./chunk-MG7AJD5E.js";
+import {
+  parseMediaType
+} from "./chunk-MWAAMNAM.js";
+
+// packages/safe-bash-docx-engine/src/comment-extensions.ts
+var commentParagraphNamespace = "http://schemas.microsoft.com/office/word/2010/wordml";
+var xmlns = "http://www.w3.org/2000/xmlns/";
+var attribute = (node, name, namespace = node.namespace) => node.attributes.find((a) => a.namespace === namespace && a.localName === name)?.value;
+function hex(value) {
+  return value?.length === 8 && [...value].every((c) => "0123456789abcdefABCDEF".includes(c)) ? value.toUpperCase() : void 0;
+}
+function assertLiveCommentExtensionPartPreserved(graph, part, bytes, budget) {
+  budget.charge("work", bytes.length + 1);
+  if (part.bytes.length === bytes.length && part.bytes.every((byte, index) => byte === bytes[index])) return;
+  const refuse = () => {
+    throw new UnsupportedEditError("Modern comment metadata cannot be synchronized safely for this edit.");
+  };
+  if (commentExtensionParts.some((descriptor) => descriptor.contentType.toLowerCase() === parseMediaType(part.content_type))) refuse();
+  const owners = ["/", ...graph.parts.filter((owner) => owner.partname !== "/[Content_Types].xml" && parseMediaType(owner.content_type) !== "application/vnd.openxmlformats-package.relationships+xml").map((owner) => owner.partname)];
+  budget.charge("retainedBytes", owners.length * 8);
+  for (const owner of owners) for (const edge of graph.relationships(owner)) {
+    budget.charge("work", 1 + commentExtensionParts.length);
+    if (!edge.is_external && commentExtensionParts.some((descriptor) => descriptor.relationship === edge.reltype) && edge.target_part.partname === part.partname) refuse();
+  }
+}
+function assertLiveCommentMetadataPreserved(previous, next, part, graph, budget) {
+  const dialect = dialectForNamespace(previous.root.namespace);
+  if (!dialect || previous.root.localName !== "comments" || previous.sourceXml(previous.root) === next.sourceXml(next.root)) return;
+  const package_ = graph();
+  if (parseMediaType(package_.getPart(part).content_type) !== "application/vnd.openxmlformats-officedocument.wordprocessingml.comments+xml") return;
+  const owners = package_.parts.filter((owner) => owner.partname !== "/[Content_Types].xml" && parseMediaType(owner.content_type) !== "application/vnd.openxmlformats-package.relationships+xml").filter((owner) => package_.relationships(owner.partname).some((edge) => edge.reltype === documentDialects[dialect].r + "/comments" && !edge.is_external && edge.target_part.partname === part));
+  const declarations = owners.flatMap((owner) => package_.relationships(owner.partname).flatMap((edge) => {
+    const descriptor = commentExtensionParts.find((candidate) => candidate.relationship === edge.reltype);
+    return descriptor ? [{ edge, descriptor }] : [];
+  }));
+  if (!declarations.length) return;
+  const physical = (root) => {
+    const result = [], pending = [root];
+    budget.charge("retainedBytes", 192);
+    while (pending.length) {
+      const node = pending.pop();
+      budget.charge("work", 1);
+      budget.charge("retainedBytes", 8 + node.children.length * 8);
+      result.push(node);
+      for (let index = node.children.length - 1; index >= 0; index--) pending.push(node.children[index]);
+    }
+    return result;
+  };
+  const word = previous.root.namespace;
+  const before = physical(previous.root).filter((node) => node.namespace === word && node.localName === "comment");
+  const after = physical(next.root).filter((node) => node.namespace === word && node.localName === "comment");
+  const contextChanged = JSON.stringify(previous.root.attributes) !== JSON.stringify(next.root.attributes);
+  const byId = (nodes) => {
+    const result = /* @__PURE__ */ new Map();
+    for (const node of nodes) {
+      budget.charge("work", 1);
+      budget.charge("retainedBytes", 40);
+      const id = attribute(node, "id"), matches = result.get(id) ?? [];
+      matches.push(node);
+      result.set(id, matches);
+    }
+    return result;
+  };
+  const beforeById = byId(before), afterById = byId(after);
+  const changed = [
+    ...before.filter((node) => {
+      const matches = afterById.get(attribute(node, "id")) ?? [];
+      budget.charge("work", 1);
+      return contextChanged || matches.length !== 1 || previous.sourceXml(node) !== next.sourceXml(matches[0]);
+    }),
+    ...after.filter((node) => {
+      const matches = beforeById.get(attribute(node, "id")) ?? [];
+      budget.charge("work", 1);
+      return contextChanged || matches.length !== 1 || next.sourceXml(node) !== previous.sourceXml(matches[0]);
+    })
+  ];
+  if (!changed.length) return;
+  const refuse = () => {
+    throw new UnsupportedEditError("Live comment mutation cannot preserve its modern metadata; use only separately verified review operations.");
+  };
+  if (owners.length !== 1 || new Set(declarations.map((item) => item.descriptor.kind)).size !== declarations.length) refuse();
+  const paragraphIds = /* @__PURE__ */ new Set(), authors = /* @__PURE__ */ new Set();
+  for (const comment of changed) {
+    authors.add(attribute(comment, "author") ?? "");
+    for (const node of physical(comment)) {
+      const raw = attribute(node, "paraId", commentParagraphNamespace);
+      if (raw === void 0) continue;
+      const id = hex(raw);
+      if (!id) refuse();
+      paragraphIds.add(id);
+    }
+  }
+  for (const { edge, descriptor } of declarations) {
+    if (edge.is_external || edge.fragment || parseMediaType(edge.target_part.content_type) !== descriptor.contentType.toLowerCase()) refuse();
+    const editor = new DocumentXmlEditor(edge.target_part.bytes, {}, void 0, budget);
+    if (editor.root.namespace !== descriptor.namespace || editor.root.localName !== descriptor.root || editor.root.children.some((node) => node.namespace !== descriptor.namespace || node.localName !== descriptor.entry)) refuse();
+    if (descriptor.kind === "commentsExtensible" && !declarations.some((item) => item.descriptor.kind === "commentsIds")) refuse();
+    for (const node of editor.root.children) {
+      budget.charge("work", 1);
+      if (descriptor.kind === "people") {
+        const author = attribute(node, "author");
+        if (author === void 0 || authors.has(author)) refuse();
+      } else if (["commentsExtended", "commentsIds"].includes(descriptor.kind)) {
+        const id = hex(attribute(node, "paraId"));
+        if (!id || paragraphIds.has(id)) refuse();
+      }
+    }
+  }
+}
+function inventoryCommentExtensions(graph, editors, budget) {
+  const result = [];
+  const relationships = ["/", ...graph.parts.filter((p) => p.content_type.toLowerCase() !== "application/vnd.openxmlformats-package.relationships+xml").map((p) => p.partname)].flatMap((owner) => graph.relationships(owner));
+  for (const part of graph.parts) {
+    const type = parseMediaType(part.content_type);
+    const root = editors.get(part.partname)?.root;
+    const descriptor = commentExtensionParts.find((e) => e.contentType.toLowerCase() === type || root?.namespace === e.namespace && root.localName === e.root || relationships.some((r) => r.reltype === e.relationship && !r.is_external && r.target_part === part));
+    if (!descriptor && !["commentsExtended", "commentsIds", "commentsExtensible", "people"].some((k) => type.includes(k.toLowerCase()))) continue;
+    const entries = [];
+    if (root) {
+      const path = [];
+      const frames = [{ node: root, next: -1 }];
+      budget.charge("retainedBytes", 32);
+      while (frames.length) {
+        budget.charge("work", 1);
+        const frame = frames.at(-1);
+        if (frame.next === -1) {
+          const node = frame.node;
+          budget.charge("work", 1 + node.attributes.length + path.length);
+          budget.charge("retainedBytes", 192 + path.length * 8 + node.attributes.length * 72);
+          entries.push({ path: [...path], name: node.localName, namespace: node.namespace, attributes: node.attributes.filter((a) => a.namespace !== xmlns).map((a) => ({ name: a.localName, namespace: a.namespace, value: a.value })) });
+          frame.next = 0;
+        } else if (frame.next < frame.node.children.length) {
+          const index = frame.next++;
+          budget.charge("retainedBytes", 40);
+          path.push(index);
+          frames.push({ node: frame.node.children[index], next: -1 });
+        } else {
+          frames.pop();
+          path.pop();
+        }
+      }
+    }
+    result.push({ part: part.partname, kind: descriptor?.kind ?? "unknown", namespace: root?.namespace ?? "", entries });
+  }
+  return result;
+}
+function synchronizeCommentExtensions(state, selected, remove) {
+  if (!state.extensions.length || !selected.length) return;
+  const refuse = () => {
+    throw new UnsupportedEditError("Comment extension metadata cannot be synchronized safely.");
+  };
+  const checkShape = (node, names, children = false) => {
+    state.budget.charge("work", 1 + node.attributes.length);
+    if (node.attributes.some((a) => a.namespace !== xmlns && (a.namespace !== node.namespace || !names.includes(a.localName))) || !children && node.children.length || node.content.some((c) => c.kind !== "element" && (c.kind !== "text" || c.text.trim()))) refuse();
+  };
+  const owners = /* @__PURE__ */ new Map();
+  const allParagraphs = /* @__PURE__ */ new Set();
+  for (const record of state.records) {
+    const paragraphs = [];
+    const pending = [record.node];
+    state.budget.charge("retainedBytes", 8);
+    while (pending.length) {
+      const node = pending.pop();
+      state.budget.charge("work", 1);
+      if (node.namespace === state.w && node.localName === "p") {
+        paragraphs.push(node);
+        const raw = attribute(node, "paraId", commentParagraphNamespace);
+        if (raw !== void 0) {
+          const id2 = hex(raw);
+          if (!id2 || parseInt(id2, 16) <= 0 || parseInt(id2, 16) >= 2147483648 || allParagraphs.has(id2)) refuse();
+          allParagraphs.add(id2);
+        }
+      }
+      state.budget.charge("retainedBytes", node.children.length * 8);
+      for (let index = node.children.length - 1; index >= 0; index--) pending.push(node.children[index]);
+    }
+    const last = paragraphs.at(-1);
+    const id = last && hex(attribute(last, "paraId", commentParagraphNamespace));
+    if (id) owners.set(id, record);
+  }
+  for (const record of selected) {
+    const pending = [record.node];
+    state.budget.charge("retainedBytes", 8);
+    while (pending.length) {
+      const node = pending.pop();
+      state.budget.charge("work", 1 + node.attributes.length);
+      if (node.attributes.some((a) => a.namespace === commentParagraphNamespace && (node.namespace !== state.w || node.localName !== "p" || remove && !["paraId", "textId"].includes(a.localName)))) refuse();
+      if (!remove && node.namespace === state.w && (["footnoteRef", "endnoteRef"].includes(node.localName) || node.localName === "p" && attribute(node, "textId", commentParagraphNamespace) !== void 0)) refuse();
+      state.budget.charge("retainedBytes", node.children.length * 8);
+      for (let index = node.children.length - 1; index >= 0; index--) pending.push(node.children[index]);
+    }
+  }
+  const selectedNodes = new Set(selected.map((r) => r.node));
+  const affected = (id) => selectedNodes.has(owners.get(id).node);
+  const groups = /* @__PURE__ */ new Map();
+  for (const info of state.extensions) {
+    const descriptor = commentExtensionParts.find((e) => e.kind === info.kind);
+    const editor = state.editors.get(info.part);
+    if (!descriptor || !editor || groups.has(info.kind) || parseMediaType(state.graph.getPart(info.part).content_type) !== descriptor.contentType.toLowerCase() || editor.root.namespace !== descriptor.namespace || editor.root.localName !== descriptor.root) refuse();
+    const edges = state.graph.relationships(state.main).filter((e) => e.reltype === descriptor.relationship);
+    if (edges.length !== 1 || edges[0].is_external || edges[0].fragment || edges[0].target_part.partname !== info.part) refuse();
+    checkShape(editor.root, [], true);
+    if (editor.root.children.some((n) => n.namespace !== descriptor.namespace || n.localName !== descriptor.entry)) refuse();
+    groups.set(info.kind, { editor, nodes: editor.root.children });
+  }
+  const byParagraph = (kind) => {
+    const map = /* @__PURE__ */ new Map();
+    for (const node of groups.get(kind)?.nodes ?? []) {
+      const id = hex(attribute(node, "paraId"));
+      if (!id || !owners.has(id) || map.has(id)) refuse();
+      map.set(id, node);
+    }
+    return map;
+  };
+  const threads = byParagraph("commentsExtended"), ids = byParagraph("commentsIds");
+  const durable = /* @__PURE__ */ new Map();
+  for (const [id, node] of ids) {
+    const value = hex(attribute(node, "durableId"));
+    if (!value || parseInt(value, 16) <= 0 || parseInt(value, 16) >= 2147483647 || durable.has(value)) refuse();
+    durable.set(value, id);
+  }
+  const parents = /* @__PURE__ */ new Map();
+  for (const [id, node] of threads) {
+    const raw = attribute(node, "paraIdParent");
+    if (raw !== void 0) {
+      const parent = hex(raw);
+      if (!parent || !threads.has(parent) || parent === id) refuse();
+      parents.set(id, parent);
+      if (remove && affected(parent) && !affected(id)) refuse();
+    }
+    const done = attribute(node, "done");
+    if (done !== void 0 && !["0", "1", "true", "false", "on", "off"].includes(done)) refuse();
+  }
+  for (const id of parents.keys()) {
+    const seen = /* @__PURE__ */ new Set();
+    let current = id;
+    while (current) {
+      state.budget.charge("work", 1);
+      if (seen.has(current)) refuse();
+      seen.add(current);
+      current = parents.get(current);
+    }
+  }
+  const deletions = [];
+  for (const [kind, entries, names] of [["commentsExtended", threads, ["paraId", "paraIdParent", "done"]], ["commentsIds", ids, ["paraId", "durableId"]]]) {
+    for (const [id, node] of entries) if (affected(id)) {
+      checkShape(node, names);
+      if (remove) deletions.push({ editor: groups.get(kind).editor, node });
+    }
+  }
+  const seenDurable = /* @__PURE__ */ new Set();
+  for (const node of groups.get("commentsExtensible")?.nodes ?? []) {
+    const id = hex(attribute(node, "durableId"));
+    if (!id || !durable.has(id) || seenDurable.has(id)) refuse();
+    seenDurable.add(id);
+    if (!affected(durable.get(id))) continue;
+    checkShape(node, ["durableId", "dateUtc", "intelligentPlaceholder"]);
+    const placeholder = attribute(node, "intelligentPlaceholder");
+    if (placeholder !== void 0 && (!["0", "false", "off"].includes(placeholder) || parents.has(durable.get(id)))) refuse();
+    if (remove) deletions.push({ editor: groups.get("commentsExtensible").editor, node });
+  }
+  if (!remove) {
+    for (const record of selected) if (record.node.children.length !== 1 || record.node.children[0].localName !== "p") refuse();
+  } else {
+    const authors = /* @__PURE__ */ new Set();
+    const unverifiedAuthors = /* @__PURE__ */ new Set();
+    for (const editor of state.editors.values()) {
+      const pending = [editor.root];
+      state.budget.charge("retainedBytes", 8);
+      while (pending.length) {
+        const node = pending.pop();
+        state.budget.charge("work", 1);
+        if (selectedNodes.has(node)) continue;
+        const author = attribute(node, "author", state.w);
+        if (author !== void 0) {
+          const verified = node.namespace === state.w && ["comment", "ins", "del", "moveFrom", "moveTo", "rPrChange", "pPrChange", "sectPrChange", "tblPrChange", "trPrChange", "tcPrChange", "tblGridChange", "numberingChange", "cellIns", "cellDel", "cellMerge", "tblPrExChange"].includes(node.localName) || node.namespace === commentParagraphNamespace && ["conflictIns", "conflictDel"].includes(node.localName);
+          (verified ? authors : unverifiedAuthors).add(author);
+        }
+        state.budget.charge("retainedBytes", node.children.length * 8);
+        for (let index = node.children.length - 1; index >= 0; index--) pending.push(node.children[index]);
+      }
+    }
+    const removedAuthors = new Set(selected.map((r) => attribute(r.node, "author", state.w) ?? ""));
+    for (const node of groups.get("people")?.nodes ?? []) {
+      const author = attribute(node, "author");
+      if (author === void 0) refuse();
+      if (!removedAuthors.has(author) || authors.has(author)) continue;
+      if (unverifiedAuthors.has(author)) refuse();
+      checkShape(node, ["author"], true);
+      if (node.children.length > 1) refuse();
+      for (const child of node.children) {
+        if (child.namespace !== node.namespace || child.localName !== "presenceInfo") refuse();
+        checkShape(child, ["providerId", "userId"]);
+      }
+      deletions.push({ editor: groups.get("people").editor, node });
+    }
+  }
+  for (const { editor, node } of deletions) editor.replaceElement(node, "");
+}
+
+export {
+  commentParagraphNamespace,
+  assertLiveCommentExtensionPartPreserved,
+  assertLiveCommentMetadataPreserved,
+  inventoryCommentExtensions,
+  synchronizeCommentExtensions
+};