@poe-platform/safe-bash 0.1.806 → 0.1.807

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

@@ -0,0 +1,139 @@
+import {
+  applyShapePath,
+  readShapePath,
+  shapePathXml,
+  validateShapePath
+} from "./chunk-H2NWPMNW.js";
+import {
+  addShape,
+  nodeFor,
+  selected,
+  validateSelection
+} from "./chunk-QHS7PDG3.js";
+import {
+  validateShapeOptions
+} from "./chunk-HHLVI2CB.js";
+import {
+  Length
+} from "./chunk-I6AMDG2T.js";
+import {
+  loadShared,
+  required
+} from "./chunk-RAXJVM4U.js";
+import {
+  SelectionError
+} from "./chunk-CKEODJVT.js";
+import {
+  OfficeError
+} from "./chunk-RR6QQ25D.js";
+
+// packages/safe-bash-presentation-engine/src/shape-path-operations.ts
+function optionsFor(options, adding = false) {
+  if (!options || typeof options !== "object" || ![Object.prototype, null].includes(Object.getPrototypeOf(options)) || Reflect.ownKeys(options).some(
+    (key) => typeof key !== "string" || !("value" in Object.getOwnPropertyDescriptor(options, key))
+  ))
+    throw new OfficeError("invalid-value", "Invalid path options.", "usage");
+  if (!adding && Object.hasOwn(options, "update"))
+    throw new OfficeError("invalid-value", "Unexpected path edit property.", "usage");
+  const { path, ...rest } = options;
+  validateShapePath(path);
+  validateSelection(rest, adding ? "add" : "set");
+  if (adding) {
+    const update = options.update;
+    if (!update || typeof update !== "object" || ![Object.prototype, null].includes(Object.getPrototypeOf(update)) || Reflect.ownKeys(update).some(
+      (key) => typeof key !== "string" || !("value" in Object.getOwnPropertyDescriptor(update, key))
+    ) || Object.hasOwn(update, "kind"))
+      throw new OfficeError(
+        "invalid-value",
+        "Path creation does not accept a preset kind.",
+        "usage"
+      );
+    for (const key of ["left", "top", "width", "height", "lineWidth"]) {
+      const value = update[key];
+      if (value && typeof value === "object") {
+        const allowed = value instanceof Length ? ["emu"] : ["value", "unit"];
+        if (Reflect.ownKeys(value).some(
+          (name) => typeof name !== "string" || !allowed.includes(name) || !("value" in Object.getOwnPropertyDescriptor(value, name))
+        ) || allowed.some((name) => !Object.hasOwn(value, name)))
+          throw new OfficeError("invalid-value", "Path lengths require data properties.", "usage");
+      }
+    }
+    validateShapeOptions({ ...update, kind: "RECTANGLE" }, true);
+  }
+  return rest;
+}
+async function readShapePaths(input, options, context) {
+  validateSelection(options, "read");
+  const s = await loadShared(input, context, false);
+  return selected(s, options).filter(
+    (record) => ["sp", "pic", "cxnSp"].includes(nodeFor(s.doc(record.part).root, record.id).name.localName)
+  ).map((record) => {
+    const doc = s.doc(record.part);
+    return {
+      ...readShapePath(doc, nodeFor(doc.root, record.id)),
+      shapeId: Number(record.id),
+      name: record.name,
+      location: record.location,
+      token: record.token,
+      part: record.part
+    };
+  });
+}
+async function setShapePath(input, options, context) {
+  optionsFor(options);
+  const s = await loadShared(input, context);
+  if (!options.select && options.shape === void 0 && options.slide === void 0 && !options.part && !options.all)
+    throw new SelectionError("invalid-selection");
+  const records = selected(s, options);
+  if (!records.length && !options.allowEmpty) throw new SelectionError("missing-selection");
+  if (records.length > 1 && !options.all)
+    throw new SelectionError(
+      "ambiguous-selection",
+      records.map((x) => x.location)
+    );
+  for (const record of records) {
+    const doc = s.doc(record.part);
+    s.save(record.part, applyShapePath(doc, nodeFor(doc.root, record.id), options.path));
+  }
+  return {
+    ...await s.finish(
+      records[0]?.part ?? s.main,
+      s.index.inventory.slides.filter((x) => records.some((r) => [x.part, x.master, x.layout].includes(r.part))).map((x) => x.position)
+    ),
+    affected: records.length,
+    records
+  };
+}
+async function addShapePath(input, options, context) {
+  optionsFor(options, true);
+  const { path, update, ...selection } = options;
+  const added = await addShape(
+    input,
+    { ...selection, update: { ...update, kind: "RECTANGLE" } },
+    context
+  );
+  const record = added.records[0];
+  const s = await loadShared(added.bytes, context);
+  const doc = s.doc(record.part), node = nodeFor(doc.root, record.id), props = required(node, "spPr");
+  const preset = props.children.find((x) => x.name.localName === "prstGeom");
+  s.save(
+    record.part,
+    doc.spliceChildren(props, props.children.indexOf(preset), 1, [
+      shapePathXml(path, preset.name.namespace)
+    ])
+  );
+  return {
+    ...await s.finish(
+      record.part,
+      s.index.inventory.slides.filter((x) => [x.part, x.master, x.layout].includes(record.part)).map((x) => x.position)
+    ),
+    affected: 1,
+    records: added.records
+  };
+}
+
+export {
+  readShapePaths,
+  setShapePath,
+  addShapePath
+};

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

@@ -0,0 +1,177 @@
+import {
+  openDocumentLocations
+} from "./chunk-LHDB4QO5.js";
+import {
+  DocumentPackage
+} from "./chunk-GLPIFP7N.js";
+import {
+  DocumentXmlEditor,
+  activeXmlChildren
+} from "./chunk-YPVBU7QF.js";
+import {
+  trimXmlWhitespace
+} from "./chunk-VEUQWV2V.js";
+import {
+  dialectForNamespace,
+  documentDialects
+} from "./chunk-MG7AJD5E.js";
+import {
+  compatibilityContainers
+} from "./chunk-GZ2N24A2.js";
+import {
+  InvalidPackageError,
+  isXmlContentType
+} from "./chunk-MWAAMNAM.js";
+import {
+  archiveSettings
+} from "./chunk-IQFRPIXH.js";
+
+// packages/safe-bash-docx-engine/src/notes-state.ts
+function noteAttribute(node, name) {
+  return node.attributes.find((a) => a.namespace === node.namespace && a.localName === name)?.value;
+}
+function idOf(node) {
+  const attribute = noteAttribute(node, "id");
+  const raw = attribute === void 0 ? void 0 : trimXmlWhitespace(attribute);
+  const digits = raw?.startsWith("-") || raw?.startsWith("+") ? raw.slice(1) : raw;
+  if (!digits || [...digits].some((c) => c < "0" || c > "9") || !Number.isSafeInteger(Number(raw)))
+    throw new InvalidPackageError("Note IDs must be bounded integers with an explicit value.");
+  return Number(raw);
+}
+function numbering(node, kind, fallback, children) {
+  const properties = node ? children(node).filter((n) => n.namespace === node.namespace && n.localName === kind + "Pr") : [];
+  if (properties.length > 1) throw new InvalidPackageError("Duplicate note numbering properties.");
+  const values = (name) => {
+    const nodes = properties[0] ? children(properties[0]).filter((n) => n.namespace === properties[0].namespace && n.localName === name) : [];
+    if (nodes.length > 1) throw new InvalidPackageError("Duplicate note numbering rule.");
+    const value = nodes[0] && noteAttribute(nodes[0], "val");
+    if (nodes.length && !value) throw new InvalidPackageError("Note numbering rules require a value.");
+    return value;
+  };
+  const storedStart = values("numStart"), restart = values("numRestart");
+  const start = storedStart === void 0 ? void 0 : trimXmlWhitespace(storedStart);
+  const digits = start?.startsWith("+") || start?.startsWith("-") ? start.slice(1) : start;
+  if (start !== void 0 && (!digits || [...digits].some((c) => c < "0" || c > "9") || !Number.isSafeInteger(Number(start))))
+    throw new InvalidPackageError("Note numbering start must be a bounded integer.");
+  if (restart !== void 0 && !["continuous", "eachSect", "eachPage"].includes(restart)) throw new InvalidPackageError("Unknown note numbering restart rule.");
+  return { format: values("numFmt") ?? fallback.format, start: start === void 0 ? fallback.start : Number(start), restart: restart ?? fallback.restart };
+}
+async function openNotes(input, context) {
+  const settings = archiveSettings(context), budget = settings.budget;
+  const document = await openDocumentLocations(input, settings), archive = document.snapshot();
+  const main = document.list("story", { scope: "body" })[0].value.part;
+  const graph = new DocumentPackage(archive, settings.limits, budget);
+  const editors = /* @__PURE__ */ new Map();
+  for (const part of graph.parts) if (isXmlContentType(part.content_type)) {
+    if (part.partname.endsWith(".rels")) continue;
+    editors.set(part.partname, new DocumentXmlEditor(part.bytes, {}, void 0, budget));
+  }
+  const mainEditor = editors.get(main);
+  const dialect = dialectForNamespace(mainEditor.root.namespace), w = documentDialects[dialect].w, r = documentDialects[dialect].r;
+  const edges = graph.relationships(main);
+  const records = [], references = [];
+  const parts = /* @__PURE__ */ new Map();
+  const reservedIds = /* @__PURE__ */ new Map();
+  const inactiveNotes = /* @__PURE__ */ new Map();
+  const stories = document.list("story", { scope: "all-stories" });
+  const annotations = document.list("annotation", { scope: "all-stories" });
+  const annotationMap = new Map(annotations.map((location) => [location.value.part + ":" + location.value.path.join("."), location]));
+  for (const kind of ["footnote", "endnote"]) {
+    const matches = edges.filter((e) => e.reltype === r + "/" + kind + "s");
+    if (matches.length > 1 || matches.some((e) => e.is_external)) throw new InvalidPackageError("Notes require one internal owning relationship per kind.");
+    if (!matches.length) continue;
+    const part = matches[0].target_part.partname, editor = editors.get(part);
+    if (!editor || editor.root.namespace !== w || editor.root.localName !== kind + "s") throw new InvalidPackageError("Note part has an invalid root.");
+    parts.set(kind, part);
+    const activeBodies = activeXmlChildren(editor, budget)(editor.root);
+    const active = new Set(activeBodies), reserved = /* @__PURE__ */ new Set(), inactive = /* @__PURE__ */ new Map();
+    const pending = [editor.root];
+    while (pending.length) {
+      const node = pending.pop();
+      budget.charge("work", 1);
+      if (node.namespace === w && node.localName === kind) {
+        const raw = noteAttribute(node, "id"), id = raw === void 0 ? NaN : Number(raw);
+        if (Number.isSafeInteger(id)) {
+          reserved.add(id);
+          if (!active.has(node)) inactive.set(id, inactive.get(id) !== false && (noteAttribute(node, "type") ?? "normal") === "normal");
+        }
+      }
+      for (const child of node.children) pending.push(child);
+    }
+    reservedIds.set(kind, reserved);
+    inactiveNotes.set(kind, inactive);
+    const used = /* @__PURE__ */ new Set(), types = /* @__PURE__ */ new Set();
+    for (const node of activeBodies) {
+      budget.charge("work", 1);
+      if (node.namespace !== w || node.localName !== kind) continue;
+      const id = idOf(node), type = noteAttribute(node, "type") ?? "normal";
+      if (used.has(id)) throw new InvalidPackageError("Duplicate note ID in its owning part.");
+      used.add(id);
+      if (!["normal", "separator", "continuationSeparator", "continuationNotice"].includes(type) || type === "normal" && id < 0)
+        throw new InvalidPackageError("Invalid note type or reserved ID.");
+      if (type !== "normal" && types.has(type)) throw new InvalidPackageError("Duplicate special note type.");
+      types.add(type);
+      const location = stories.find((s) => s.value.part === part && s.value.story === part + "#" + kind + ":" + noteAttribute(node, "id"));
+      records.push({ kind, id, type, node, editor, part, location, references: [] });
+    }
+  }
+  const byId = new Map(records.map((record) => [record.kind + ":" + record.id, record]));
+  for (const [part, editor] of editors) {
+    const containers = new Set(editor.compatibility[compatibilityContainers]);
+    const path = [];
+    const frames = [{ node: editor.root, parent: void 0, safe: true, position: -1 }];
+    while (frames.length) {
+      const frame = frames.at(-1);
+      if (frame.position >= 0) {
+        if (frame.position === frame.node.children.length) {
+          frames.pop();
+          if (frames.length) path.pop();
+        } else {
+          const index = frame.position++;
+          budget.charge("retainedBytes", 64);
+          path.push(index);
+          frames.push({
+            node: frame.node.children[index],
+            parent: containers.has(frame.node) ? frame.parent : frame.node,
+            safe: frame.safe && (containers.has(frame.node) || frame.node.namespace === w && !["sdt", "ins", "del", "moveFrom", "moveTo", "fldSimple"].includes(frame.node.localName)),
+            position: -1
+          });
+        }
+        continue;
+      }
+      const { node, parent } = frame;
+      frame.position = 0;
+      budget.charge("work", 1);
+      if (node.namespace === w && ["footnoteReference", "endnoteReference"].includes(node.localName)) {
+        const kind = node.localName === "footnoteReference" ? "footnote" : "endnote", id = idOf(node);
+        const record = byId.get(kind + ":" + id);
+        const location = parent?.namespace === w && parent.localName === "r" ? annotationMap.get(part + ":" + path.join(".")) : void 0;
+        if (record ? record.type !== "normal" : location !== void 0 || inactiveNotes.get(kind)?.get(id) !== true)
+          throw new InvalidPackageError("Note reference has no normal note body.");
+        budget.charge("retainedBytes", 128 + path.length * 8);
+        const reference = { kind, id, node, editor, path: [...path], part, location, safe: !!location && frame.safe };
+        references.push(reference);
+        record?.references.push(reference);
+      }
+    }
+  }
+  const defaults = { format: "decimal", start: 1, restart: "continuous" };
+  const settingsEdges = edges.filter((e) => e.reltype === r + "/settings" && !e.is_external);
+  if (settingsEdges.length > 1) throw new InvalidPackageError("Duplicate settings parts.");
+  const settingsEditor = settingsEdges[0] && editors.get(settingsEdges[0].target_part.partname);
+  const settingsNode = settingsEditor?.root;
+  const settingsChildren = settingsEditor ? activeXmlChildren(settingsEditor, budget) : (node) => node.children;
+  const sectionChildren = activeXmlChildren(mainEditor, budget);
+  const global = { footnote: numbering(settingsNode, "footnote", defaults, settingsChildren), endnote: numbering(settingsNode, "endnote", defaults, settingsChildren) };
+  const sections = document.list("section").map((location) => {
+    let node = mainEditor.root;
+    for (const i of location.value.path) node = node.children[i];
+    return { section: location.positions.section, footnote: numbering(node, "footnote", global.footnote, sectionChildren), endnote: numbering(node, "endnote", global.endnote, sectionChildren) };
+  });
+  return { document, archive, main, graph, editors, dialect, w, r, records, references, parts, reservedIds, inactiveNotes, numbering: { document: global, sections } };
+}
+
+export {
+  noteAttribute,
+  openNotes
+};

package/dist/safe-bash/command-chunks/{chunk-2UWPMSME.js → chunk-Y72LPXST.js}

@@ -1,12 +1,6 @@
-import {
-  prettyAwk
-} from "./chunk-RFFMTLU6.js";
-import {
-  AwkRetention
-} from "./chunk-4D27OCWG.js";
 import {
   AwkRuntime
-} from "./chunk-JD3NSHFT.js";
+} from "./chunk-TVGIJ56E.js";
 import {
   AwkParser,
   builtinArities,
@@ -14,10 +8,16 @@ import {
 } from "./chunk-7ADQE64C.js";
 import {
   AwkInspection
-} from "./chunk-AV6N7DDA.js";
+} from "./chunk-DDYPQAXN.js";
+import {
+  prettyAwk
+} from "./chunk-RFFMTLU6.js";
 import {
   quoteAwk
 } from "./chunk-ERHCLPDL.js";
+import {
+  AwkRetention
+} from "./chunk-4D27OCWG.js";
 
 // packages/safe-bash-command-awk/src/awk.ts
 import { writeFileOutput } from "../../safe-bash-contracts/filesystem-output.js";

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

@@ -0,0 +1,69 @@
+import {
+  customXmlDataNamespaces,
+  customXmlRelationshipNamespaces
+} from "./chunk-2A6TBB4F.js";
+import {
+  documentPartRole
+} from "./chunk-DXX2Z2QA.js";
+import {
+  activeXmlChildren
+} from "./chunk-YPVBU7QF.js";
+import {
+  isXmlContentType,
+  parseDocumentXml
+} from "./chunk-MWAAMNAM.js";
+
+// packages/safe-bash-docx-engine/src/binding-ownership.ts
+function readDocumentBindingOwnership(graph, budget) {
+  budget.charge("work", 1);
+  const declarations = [], stores = [], roots = /* @__PURE__ */ new Map();
+  for (const part of graph.parts) {
+    budget.charge("work", 1);
+    const type = part.content_type.toLowerCase();
+    if (type === "application/vnd.openxmlformats-package.relationships+xml" || !isXmlContentType(type)) continue;
+    const root = parseDocumentXml(part.bytes, {}, budget).root;
+    roots.set(part.partname, root);
+    const role = documentPartRole(type, root);
+    if (role !== "story" && role !== "glossary" && role !== "settings") continue;
+    const active = activeXmlChildren(root, budget);
+    const logicalParents = /* @__PURE__ */ new Map(), physicalParents = /* @__PURE__ */ new Map();
+    const paths = /* @__PURE__ */ new Map(), pending = [{ node: root, path: [] }];
+    budget.charge("retainedBytes", 64);
+    while (pending.length) {
+      const { node, path } = pending.pop();
+      budget.charge("work", node.children.length + node.attributes.length + 1);
+      budget.charge("retainedBytes", 64 + node.children.length * (128 + (path.length + 1) * 8));
+      paths.set(node, path);
+      for (const child of active(node)) logicalParents.set(child, node);
+      for (const [index, child] of node.children.entries()) {
+        physicalParents.set(child, node);
+        pending.push({ node: child, path: [...path, index] });
+      }
+    }
+    for (const [node, path] of paths) {
+      if (node.namespace !== root.namespace || node.localName !== "dataBinding") continue;
+      const owner = (parents) => {
+        const parent = parents.get(node), grandparent = parent && parents.get(parent);
+        return parent?.namespace === root.namespace && parent.localName === "sdtPr" && grandparent?.namespace === root.namespace && grandparent.localName === "sdt" ? grandparent : void 0;
+      };
+      const control = owner(logicalParents) ?? owner(physicalParents);
+      if (!control) continue;
+      budget.charge("retainedBytes", 64 + path.length * 8);
+      const attr = (name) => node.attributes.find((attribute) => attribute.namespace === node.namespace && attribute.localName === name)?.value ?? null;
+      declarations.push({ part: part.partname, path, controlPath: paths.get(control), storeItemId: attr("storeItemID"), xpath: attr("xpath"), prefixMappings: attr("prefixMappings"), supportedStory: role === "story" });
+    }
+  }
+  for (const part of graph.parts.filter((part2) => part2.content_type.toLowerCase() !== "application/vnd.openxmlformats-package.relationships+xml")) for (const edge of graph.relationships(part.partname)) {
+    budget.charge("work", 1);
+    if (!customXmlRelationshipNamespaces.some((namespace) => edge.reltype === namespace + "customXmlProps") || edge.is_external) continue;
+    const root = roots.get(edge.target_part.partname);
+    if (!root || !customXmlDataNamespaces.includes(root.namespace) || root.localName !== "datastoreItem") continue;
+    budget.charge("retainedBytes", 64);
+    stores.push({ item: part.partname, properties: edge.target_part.partname, storeItemId: root.attributes.find((attribute) => attribute.namespace === root.namespace && attribute.localName === "itemID")?.value ?? null });
+  }
+  return { declarations, stores };
+}
+
+export {
+  readDocumentBindingOwnership
+};

package/dist/safe-bash/command-chunks/{chunk-P4OJBL2B.js → chunk-YFZ6FPIC.js}

@@ -1,4 +1,4 @@
-// packages/safe-bash-command-node/src/integrations/safejs/filesystem.ts
+// packages/safe-bash-command-safejs/src/filesystem.ts
 function makeSafeJsFsModule(makeFsModule, fs, options = {}) {
   return makeFsModule({ adapter: fs, ...options });
 }

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

@@ -0,0 +1,171 @@
+import {
+  measurePackageResourceSerialization
+} from "./chunk-W6DV2CLS.js";
+import {
+  validateDocxInvocation
+} from "./chunk-DE66JRWJ.js";
+import {
+  retainedRelationshipTargets
+} from "./chunk-4LXDJES2.js";
+import {
+  publishDocumentArchive
+} from "./chunk-HPKUFWHW.js";
+import {
+  signatureContentTypes,
+  signatureRelationshipTypes
+} from "./chunk-DXX2Z2QA.js";
+import {
+  readDocumentArchive
+} from "./chunk-GLPIFP7N.js";
+import {
+  DocumentXmlEditor,
+  UnsupportedEditError,
+  editActiveRelationshipXml
+} from "./chunk-YPVBU7QF.js";
+import {
+  relationshipXmlRows
+} from "./chunk-2PSVE7I5.js";
+import {
+  compareInventoryNames
+} from "./chunk-2EUH5B6A.js";
+import {
+  SelectionError,
+  encodeGeneratedLocation
+} from "./chunk-LQOKYG3O.js";
+import {
+  asciiKey
+} from "./chunk-WAKYUXVQ.js";
+import {
+  InputTypeError,
+  archiveSettings
+} from "./chunk-IQFRPIXH.js";
+
+// packages/safe-bash-docx-engine/src/signatures.ts
+var relationshipsType = "application/vnd.openxmlformats-package.relationships+xml";
+function relationshipPart(owner) {
+  if (owner === "/") return "/_rels/.rels";
+  const slash = owner.lastIndexOf("/");
+  return owner.slice(0, slash + 1) + "_rels/" + owner.slice(slash + 1) + ".rels";
+}
+function signatureGraph(archive, budget) {
+  const parts = new Set(archive.package.parts.filter((part) => signatureContentTypes.includes(asciiKey(part.content_type))).map((part) => part.partname));
+  const all = [], relationships = [];
+  const owners = ["/", ...archive.package.parts.filter((part) => asciiKey(part.content_type) !== relationshipsType).map((part) => part.partname)];
+  budget.charge("retainedBytes", owners.length * 8);
+  owners.sort((left, right) => {
+    budget.charge("work", left.length + right.length);
+    budget.charge("retainedBytes", (left.length + right.length) * 8);
+    return compareInventoryNames(left, right);
+  });
+  for (const owner of owners) {
+    for (const edge of archive.package.relationships(owner)) {
+      budget.charge("work", 1);
+      budget.charge("retainedBytes", 192 + owner.length * 2 + edge.rId.length * 2 + edge.reltype.length * 2);
+      const reference = { owner, id: edge.rId, type: edge.reltype, target: edge.is_external ? null : edge.target_part.partname, external: edge.is_external };
+      all.push(reference);
+      if (signatureRelationshipTypes.includes(edge.reltype)) {
+        relationships.push(reference);
+        if (reference.target !== null) parts.add(reference.target);
+      }
+    }
+  }
+  budget.check("matches", parts.size + relationships.length);
+  return { parts, all, relationships };
+}
+async function inspectDocumentSignatures(input, options, context) {
+  const settings = archiveSettings(context);
+  const invocation = validateDocxInvocation({ operation: "signatures.list", inputs: ["document"], options }, settings.budget);
+  const budget = settings.budget.lower(Object.fromEntries((invocation.options.limit ?? []).map((limit) => [limit.name, limit.value])));
+  if (!(input instanceof Uint8Array)) throw new InputTypeError("Expected archive bytes.");
+  budget.check("compressedInput", input.length);
+  budget.charge("retainedBytes", input.length);
+  const ownedInput = new Uint8Array(input);
+  const archive = await readDocumentArchive(ownedInput, { ...settings, budget }), graph = signatureGraph(archive, budget);
+  budget.charge("work", input.length);
+  const sourceSha256 = [...new Uint8Array(await crypto.subtle.digest("SHA-256", ownedInput))].map((value) => value.toString(16).padStart(2, "0")).join("");
+  const items = [];
+  for (const part of archive.package.parts) if (graph.parts.has(part.partname)) {
+    const value = { version: 1, sourceSha256, generation: 0, part: part.partname, story: part.partname, path: [], range: null };
+    const location = { kind: "part", value, token: encodeGeneratedLocation(value), positions: {} };
+    budget.charge("retainedBytes", location.token.length * 4 + 256);
+    budget.charge("work", part.bytes.length);
+    budget.charge("retainedBytes", part.bytes.length + 192 + (part.partname.length + part.content_type.length) * 2);
+    const digest = await crypto.subtle.digest("SHA-256", new Uint8Array(part.bytes));
+    budget.check("work", 0);
+    const sha256 = [...new Uint8Array(digest)].map((value2) => value2.toString(16).padStart(2, "0")).join("");
+    items.push({ name: part.partname, kind: "signatures", location, support: "read", properties: [], references: [], details: { kind: "signatures", parts: [{ name: part.partname, contentType: part.content_type, bytes: part.bytes.length, sha256 }] } });
+  }
+  const data = { items: items.sort((left, right) => compareInventoryNames(left.name, right.name)), relationships: graph.relationships, verified: null };
+  measurePackageResourceSerialization(data, budget);
+  return data;
+}
+async function stripDocumentSignatures(input, options, context) {
+  const settings = archiveSettings(context), { input: identity, ...operationOptions } = options;
+  const invocation = validateDocxInvocation({ operation: "signatures.remove", inputs: [identity?.path ?? "document"], options: operationOptions }, settings.budget);
+  const opts = invocation.options;
+  const budget = settings.budget.lower(Object.fromEntries((opts.limit ?? []).map((limit) => [limit.name, limit.value])));
+  const archive = await readDocumentArchive(input, { ...settings, budget }), graph = signatureGraph(archive, budget);
+  if (!graph.parts.size && !graph.relationships.length && !opts.allowEmpty) throw new SelectionError("missing-selection", []);
+  if (archive.package.parts.some((part) => graph.parts.has(part.partname) && (part.partname === archive.mainPart || asciiKey(part.content_type).startsWith("application/vnd.openxmlformats-officedocument.wordprocessingml.")))) throw new UnsupportedEditError("Signature graph overlaps the document owner.");
+  for (const edge of graph.all) {
+    if (signatureRelationshipTypes.includes(edge.type)) continue;
+    if (graph.parts.has(edge.owner) || edge.target !== null && graph.parts.has(edge.target)) throw new UnsupportedEditError("Signature graph has unsupported or shared relationships.");
+  }
+  const removedRelationships = graph.all.filter((edge) => signatureRelationshipTypes.includes(edge.type) || graph.parts.has(edge.owner));
+  const retainedTargets = retainedRelationshipTargets(archive.package, budget, removedRelationships);
+  if ([...graph.parts].some((part) => retainedTargets.has(asciiKey(part)))) throw new UnsupportedEditError("Signature graph has retained inactive relationships.");
+  const removed = new Set(graph.parts);
+  const ownedRelationshipNames = new Set([...graph.parts].map((owner) => asciiKey(relationshipPart(owner))));
+  for (const part of archive.package.parts) if (ownedRelationshipNames.has(asciiKey(part.partname))) removed.add(part.partname);
+  const removedParts = archive.package.parts.filter((part) => removed.has(part.partname)).map((part) => part.partname);
+  const removedContentTypes = [];
+  const relationshipsByPart = /* @__PURE__ */ new Map();
+  for (const edge of removedRelationships) {
+    const name = asciiKey(relationshipPart(edge.owner)), ids = relationshipsByPart.get(name) ?? /* @__PURE__ */ new Set();
+    ids.add(edge.id);
+    relationshipsByPart.set(name, ids);
+  }
+  const memberPartNames = new Map(archive.package.parts.map((part) => [part.name, part.partname]));
+  const members = archive.members.filter((member) => !removed.has(memberPartNames.get(member.name) ?? "")).map((member) => {
+    if (member.directory) return member;
+    const partname = memberPartNames.get(member.name) ?? "/[Content_Types].xml";
+    if (asciiKey(partname) === "/[content_types].xml") {
+      const editor2 = new DocumentXmlEditor(member.bytes, {}, void 0, budget);
+      for (const node of editor2.root.children) {
+        const attribute = (name2) => node.attributes.find((value) => !value.namespace && value.localName === name2)?.value;
+        const contentType = attribute("ContentType");
+        const name = attribute(node.localName === "Override" ? "PartName" : "Extension");
+        const drop = node.localName === "Override" ? removed.has(archive.package.getPart(name).partname) : signatureContentTypes.includes(asciiKey(contentType));
+        if (drop) {
+          removedContentTypes.push({ kind: node.localName === "Override" ? "override" : "default", name, contentType });
+          editor2.replaceElement(node, "");
+        }
+      }
+      return { ...member, bytes: editor2.serialize() };
+    }
+    const edges = relationshipsByPart.get(asciiKey(partname));
+    if (!edges?.size) return member;
+    const editor = new DocumentXmlEditor(member.bytes, {}, void 0, budget);
+    for (const row of relationshipXmlRows(editor.root, budget)) if (edges.has(row.rId)) editor[editActiveRelationshipXml](row.element, null);
+    return { ...member, bytes: editor.serialize() };
+  });
+  const planned = { changed: removedParts.length + removedRelationships.length + removedContentTypes.length > 0, dryRun: opts.dryRun ?? false, removedParts, removedRelationships, removedContentTypes, output: opts.dryRun ? null : { path: opts.inPlace ? identity?.path ?? null : opts.output ?? null, bytes: Math.min(settings.limits.maxArchiveBytes, Number.MAX_SAFE_INTEGER), sha256: "0".repeat(64) } };
+  measurePackageResourceSerialization(planned, budget);
+  if (context.admitPublication) {
+    const result = context.admitPublication(planned);
+    if (result !== void 0) {
+      if (result && typeof result.then === "function") void Promise.resolve(result).catch(() => {
+      });
+      throw new InputTypeError("Signature publication admission must be synchronous.");
+    }
+  }
+  const publicationOptions = { ...opts.output === void 0 ? {} : { output: opts.output }, ...opts.inPlace === void 0 ? {} : { inPlace: opts.inPlace }, ...opts.force === void 0 ? {} : { force: opts.force }, ...opts.dryRun === void 0 ? {} : { dryRun: opts.dryRun }, ...opts.json === void 0 ? {} : { json: opts.json } };
+  const candidate = { ...archive, members };
+  const published = await publishDocumentArchive(candidate, { ...publicationOptions, ...identity ? { input: identity } : {} }, { ...context, budget }, candidate);
+  return { ...planned, output: published.published.length ? { path: published.published[0].path, bytes: published.published[0].bytes, sha256: published.archiveSha256 } : null };
+}
+
+export {
+  inspectDocumentSignatures,
+  stripDocumentSignatures
+};