@poe-platform/safe-bash 0.1.806 → 0.1.807

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

@@ -0,0 +1,250 @@
+import {
+  openDocumentLocations,
+  resolveDocxSelection
+} from "./chunk-LHDB4QO5.js";
+import {
+  validateDocxInvocation
+} from "./chunk-DE66JRWJ.js";
+import {
+  hyperlinkHistory
+} from "./chunk-NYBF2BVE.js";
+import {
+  paragraphTextRun
+} from "./chunk-GGOZXIGH.js";
+import {
+  findRelationshipPart
+} from "./chunk-4LXDJES2.js";
+import {
+  LocationIndex,
+  addressKey
+} from "./chunk-IR6ZKAUH.js";
+import {
+  assertDocumentEditable,
+  publishDocumentArchive
+} from "./chunk-HPKUFWHW.js";
+import {
+  DocumentPackage
+} from "./chunk-GLPIFP7N.js";
+import {
+  DocumentXmlEditor,
+  UnsupportedEditError,
+  activeXmlChildren,
+  editActiveRelationshipXml,
+  runElementOpen,
+  xmlValue
+} from "./chunk-YPVBU7QF.js";
+import {
+  relationshipXmlIds,
+  relationshipXmlRows
+} from "./chunk-2PSVE7I5.js";
+import {
+  dialectForNamespace,
+  documentDialects
+} from "./chunk-MG7AJD5E.js";
+import {
+  compatibilityContainers
+} from "./chunk-GZ2N24A2.js";
+import {
+  closedRecord,
+  encodeGeneratedLocation
+} from "./chunk-LQOKYG3O.js";
+import {
+  parseDocumentXml
+} from "./chunk-MWAAMNAM.js";
+import {
+  DocxUsageError
+} from "./chunk-2P7BLWWI.js";
+import {
+  archiveSettings
+} from "./chunk-IQFRPIXH.js";
+
+// packages/safe-bash-docx-engine/src/links.ts
+var relationshipsNamespace = "http://schemas.openxmlformats.org/package/2006/relationships";
+var attribute = (node, namespace, name) => node?.attributes.find((a) => a.namespace === namespace && a.localName === name)?.value;
+async function inspectDocumentLinks(input, options, context) {
+  const settings = archiveSettings(context);
+  const invocation = validateDocxInvocation({ operation: "links.list", inputs: ["document"], options }, settings.budget);
+  const budget = settings.budget.lower(Object.fromEntries((options.limit ?? []).map((item) => [item.name, item.value])));
+  const document = await openDocumentLocations(input, { ...settings, budget });
+  const selected = resolveDocxSelection(document, invocation);
+  budget.check("matches", selected.length);
+  const archive = document.snapshot();
+  const graph = new DocumentPackage(archive, settings.limits, budget);
+  const roots = /* @__PURE__ */ new Map();
+  const items = [];
+  for (const location of selected) {
+    await budget.checkpoint();
+    let root = roots.get(location.value.part);
+    if (!root) {
+      root = parseDocumentXml(graph.getPart(location.value.part).bytes, {}, budget).root;
+      roots.set(location.value.part, root);
+    }
+    let node = root;
+    for (const i of location.value.path) node = node.children[i];
+    const { w, r } = documentDialects[dialectForNamespace(node.namespace)];
+    const id = attribute(node, r, "id");
+    const edge = id === void 0 ? void 0 : graph.relationships(location.value.part).find((e) => e.rId === id);
+    if (edge && (edge.reltype !== r + "/hyperlink" || !edge.is_external)) throw new UnsupportedEditError("Link target relationship must be external or use an internal anchor.");
+    const address = edge?.target_ref ?? "", fragment = attribute(node, w, "anchor") ?? "";
+    const children = activeXmlChildren(root, budget);
+    let text = "", contains_page_break = false;
+    const visit = (current) => {
+      budget.charge("work", 1);
+      if (current.namespace !== w) return;
+      if (current.localName === "t") text += current.text;
+      else if (current.localName === "tab" || current.localName === "ptab") text += "	";
+      else if (current.localName === "noBreakHyphen") text += "\u2011";
+      else if (current.localName === "softHyphen") text += "\xAD";
+      else if (current.localName === "cr" || current.localName === "br" && (!attribute(current, w, "type") || attribute(current, w, "type") === "textWrapping")) text += "\n";
+      else if (current.localName === "lastRenderedPageBreak") contains_page_break = true;
+      else if (["hyperlink", "r"].includes(current.localName)) for (const child of children(current)) visit(child);
+    };
+    visit(node);
+    items.push({ location, text, address, fragment, url: address ? address + (fragment ? "#" + fragment : "") : "", history: hyperlinkHistory(attribute(node, w, "history")), contains_page_break });
+  }
+  const data = { items };
+  budget.check("serializedOutput", new TextEncoder().encode(JSON.stringify({ version: 1, operation: "links.list", ok: true, data, affected: 0, locations: items.map((i) => i.location), warnings: [], errors: [] }) + "\n").length);
+  return data;
+}
+async function editDocumentLinks(input, request, context) {
+  closedRecord(request, ["operation", "options", "input"]);
+  if (!["links.add", "links.set", "links.remove"].includes(request.operation)) throw new DocxUsageError("Expected a link editing operation.");
+  const settings = archiveSettings(context);
+  const invocation = validateDocxInvocation({ operation: request.operation, inputs: [request.input?.path ?? "document"], options: request.options }, settings.budget);
+  const options = invocation.options;
+  const budget = settings.budget.lower(Object.fromEntries((options.limit ?? []).map((item) => [item.name, item.value])));
+  const document = await openDocumentLocations(input, { ...settings, budget });
+  const selected = resolveDocxSelection(document, invocation);
+  budget.check("matches", selected.length);
+  let archive = document.snapshot();
+  assertDocumentEditable(archive, { ...settings, budget });
+  const graph = new DocumentPackage(archive, settings.limits, budget);
+  const mainPart = graph.getPart(document.list("story", { scope: "body" })[0].value.part), main = mainPart.name;
+  const dialect = dialectForNamespace(parseDocumentXml(mainPart.bytes, {}, budget).root.namespace);
+  const { w, r } = documentDialects[dialect];
+  const members = new Map(archive.members.map((m) => [m.name, m]));
+  const grouped = /* @__PURE__ */ new Map();
+  for (const location of selected) grouped.set(location.value.part, [...grouped.get(location.value.part) ?? [], location]);
+  const updates = [];
+  for (const [part, locations] of grouped) {
+    const name = graph.getPart(part).name, member = members.get(name);
+    let xml = new DocumentXmlEditor(member.bytes, {}, void 0, budget);
+    const split = name.lastIndexOf("/");
+    const relName = findRelationshipPart(graph, part, budget)?.name ?? name.slice(0, split + 1) + "_rels/" + name.slice(split + 1) + ".rels";
+    const relMember = members.get(relName);
+    let rels = new DocumentXmlEditor(relMember?.bytes ?? new TextEncoder().encode(`<Relationships xmlns="${relationshipsNamespace}"/>`), {}, void 0, budget);
+    const retired = /* @__PURE__ */ new Set(), reserved = relationshipXmlIds(rels.root, budget);
+    const references = (root) => {
+      const ids = /* @__PURE__ */ new Set();
+      const visit = (node) => {
+        budget.charge("work", 1);
+        for (const a of node.attributes) if (a.namespace === r) ids.add(a.value);
+        for (const child of node.children) visit(child);
+      };
+      visit(root);
+      return ids;
+    };
+    for (const id of references(xml.root)) reserved.add(id);
+    locations.sort((a, b) => {
+      const left = a.value.path, right = b.value.path;
+      for (let i = 0; i < Math.min(left.length, right.length); i++) if (left[i] !== right[i]) return right[i] - left[i];
+      return right.length - left.length;
+    });
+    for (const before of locations) {
+      await budget.checkpoint();
+      let node = xml.root, parent = node;
+      const ancestors = [node];
+      for (const position of before.value.path) {
+        parent = node;
+        node = node.children[position];
+        ancestors.push(node);
+      }
+      if (ancestors.some((n) => n.namespace === w && ["ins", "del", "moveFrom", "moveTo", "sdt", "fldSimple"].includes(n.localName))) throw new UnsupportedEditError("Links inside tracked or controlled content require dedicated operations.");
+      const adding = request.operation === "links.add";
+      const containers = new Set(xml.compatibility[compatibilityContainers]);
+      let paragraphPosition = ancestors.length - 2;
+      while (paragraphPosition > 0 && containers.has(ancestors[paragraphPosition])) paragraphPosition--;
+      const paragraph = ancestors[paragraphPosition];
+      if (node.namespace !== w || (adding ? node.localName !== "p" : node.localName !== "hyperlink" || paragraph.namespace !== w || paragraph.localName !== "p")) throw new UnsupportedEditError("Link insertion requires a paragraph; link edits require a direct paragraph hyperlink.");
+      const oldId = attribute(node, r, "id"), anchor = attribute(node, w, "anchor");
+      const oldEdge = relationshipXmlRows(rels.root, budget).find((edge) => edge.rId === oldId);
+      if (oldEdge && (oldEdge.reltype !== r + "/hyperlink" || !oldEdge.is_external)) throw new UnsupportedEditError("Unsupported link relationship.");
+      if (!adding && request.operation === "links.set" && attribute(node, w, "docLocation") === void 0 && (options.target !== void 0 ? oldEdge?.target_ref === options.target && anchor === void 0 : anchor === options.bookmark && oldId === void 0)) continue;
+      let destination = "";
+      if (request.operation !== "links.remove") {
+        if (options.target !== void 0) {
+          const edge = relationshipXmlRows(rels.root, budget).find((edge2) => edge2.reltype === r + "/hyperlink" && edge2.is_external && edge2.target_ref === options.target);
+          let id = edge?.rId;
+          if (!id) {
+            let n = 1;
+            while (reserved.has("rId" + n)) {
+              budget.charge("work", 1);
+              n++;
+            }
+            id = "rId" + n;
+            reserved.add(id);
+            rels.insertChildren(rels.root, `<Relationship xmlns="${relationshipsNamespace}" Id="${id}" Type="${r}/hyperlink" Target="${xmlValue(options.target)}" TargetMode="External"/>`);
+            rels = new DocumentXmlEditor(rels.serialize(), {}, void 0, budget);
+          }
+          destination = ` xmlns:lr="${r}" lr:id="${id}"`;
+        } else destination = ` xmlns:lw="${w}" lw:anchor="${xmlValue(options.bookmark)}"`;
+      }
+      if (adding) {
+        const path = [...before.value.path, node.children.length];
+        xml.insertChildren(node, `<lh:hyperlink xmlns:lh="${w}"${destination}>${paragraphTextRun(w, options.text)}</lh:hyperlink>`);
+        updates.push({ before, path, kind: "insert", locationKind: "link" });
+      } else if (request.operation === "links.set") {
+        const open = runElementOpen({ ...node, attributes: node.attributes.filter((a) => !(a.namespace === r && a.localName === "id") && !(a.namespace === w && ["anchor", "docLocation"].includes(a.localName))) });
+        const targetAttribute = options.target !== void 0 ? { namespace: r, name: "id", value: relationshipXmlRows(rels.root, budget).find((edge) => edge.reltype === r + "/hyperlink" && edge.is_external && edge.target_ref === options.target).rId } : { namespace: w, name: "anchor", value: options.bookmark };
+        let prefix = [...node.namespaces].find(([p, ns]) => p && ns === targetAttribute.namespace)?.[0];
+        if (!prefix) {
+          prefix = "link";
+          while (node.namespaces.has(prefix)) prefix += "x";
+        }
+        const declaration = node.namespaces.get(prefix) === targetAttribute.namespace ? "" : ` xmlns:${prefix}="${targetAttribute.namespace}"`;
+        xml.replaceElement(node, open.slice(0, -1) + declaration + ` ${prefix}:${targetAttribute.name}="${xmlValue(targetAttribute.value)}">` + xml.sourceXml(node, /* @__PURE__ */ new Map(), true) + `</${node.name}>`);
+        updates.push({ before, path: before.value.path, kind: "target", locationKind: "link" });
+      } else {
+        const bindingsChanged = [...node.namespaces].some(([prefix, uri]) => parent.namespaces.get(prefix) !== uri);
+        const inherited = node.attributes.filter((a) => a.namespace === "http://www.w3.org/XML/1998/namespace" && ["space", "lang"].includes(a.localName));
+        const label = options.deleteContent ? "" : xml.sourceXml(node, bindingsChanged || inherited.length ? new Map(node.children.map((child) => {
+          const attributes = [...child.attributes, ...inherited.filter((a) => !child.attributes.some((b) => b.namespace === a.namespace && b.localName === a.localName))];
+          return [child, runElementOpen({ ...child, attributes }) + xml.sourceXml(child, /* @__PURE__ */ new Map(), true) + `</${child.name}>`];
+        })) : /* @__PURE__ */ new Map(), true);
+        xml.replaceElement(node, label);
+        updates.push({ before, path: before.value.path.slice(0, paragraphPosition), kind: options.deleteContent ? "remove" : "unwrap", locationKind: "paragraph" });
+      }
+      if (oldId) retired.add(oldId);
+      xml = new DocumentXmlEditor(xml.serialize(), {}, void 0, budget);
+    }
+    const used = references(xml.root);
+    for (const id of retired) if (!used.has(id)) {
+      const edge = relationshipXmlRows(rels.root, budget).find((row) => row.rId === id);
+      if (edge) {
+        rels[editActiveRelationshipXml](edge.element, null);
+        rels = new DocumentXmlEditor(rels.serialize(), {}, void 0, budget);
+      }
+    }
+    members.set(name, { ...member, bytes: xml.serialize() });
+    if (relMember || rels.root.children.length) members.set(relName, { ...relMember ?? { name: relName, directory: false, modified: /* @__PURE__ */ new Date("1980-01-01T00:00:00Z") }, bytes: rels.serialize() });
+  }
+  archive = { ...archive, members: [...members.values()] };
+  const index = new LocationIndex(archive, settings.limits, main, dialect, budget);
+  const changes = updates.sort((a, b) => selected.indexOf(a.before) - selected.indexOf(b.before)).map(({ before, path, kind, locationKind }) => {
+    const entry = index.byAddress.get(addressKey({ ...before.value, path }))?.find((e) => e.kind === locationKind);
+    if (!entry) throw new UnsupportedEditError("Link edit could not resolve its resulting location.");
+    const value = { ...before.value, generation: 1, path, range: null };
+    const after = { kind: locationKind, value, token: encodeGeneratedLocation(value), positions: entry.positions };
+    return { kind, before, after };
+  });
+  const publication = { ...request.input ? { input: request.input } : {}, ...options.output === void 0 ? {} : { output: options.output }, ...options.inPlace === void 0 ? {} : { inPlace: options.inPlace }, ...options.force === void 0 ? {} : { force: options.force }, ...options.dryRun === void 0 ? {} : { dryRun: options.dryRun }, ...options.json === void 0 ? {} : { json: options.json } };
+  const prospective = { changed: changes.length > 0, changes, dryRun: options.dryRun ?? false, output: options.dryRun ? null : { path: options.inPlace ? request.input?.path ?? null : options.output === "-" ? null : options.output ?? null, bytes: Math.min(settings.limits.maxArchiveBytes, Number.MAX_SAFE_INTEGER), sha256: "0".repeat(64) } };
+  budget.check("serializedOutput", new TextEncoder().encode(JSON.stringify({ version: 1, operation: request.operation, ok: true, data: prospective, affected: changes.length, locations: changes.map((c) => c.after), warnings: [], errors: [] }) + "\n").length);
+  const result = await publishDocumentArchive(archive, publication, { ...context, budget });
+  return { changed: changes.length > 0, changes, dryRun: options.dryRun ?? false, output: result.published.length ? { path: result.published[0].path, bytes: result.published[0].bytes, sha256: result.archiveSha256 } : null };
+}
+
+export {
+  inspectDocumentLinks,
+  editDocumentLinks
+};

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

@@ -0,0 +1,116 @@
+import {
+  decodeLocation
+} from "./chunk-LQOKYG3O.js";
+import {
+  DocxUsageError
+} from "./chunk-2P7BLWWI.js";
+
+// packages/safe-bash-docx-engine/src/command-selection.ts
+var resourceSelectors = {
+  paragraphs: "paragraph",
+  runs: "run",
+  tables: "table",
+  sections: "section",
+  headers: "section",
+  footers: "section",
+  lists: "paragraph",
+  links: "link",
+  bookmarks: "bookmark",
+  fields: "field",
+  toc: "field",
+  captions: "field",
+  notes: "note",
+  comments: "comment",
+  revisions: "revision",
+  controls: "control",
+  images: "image",
+  shapes: "shape",
+  lorem: "paragraph"
+};
+var ordinalSelectors = ["section", "table", "cell", "paragraph", "run", "image", "link", "control", "revision", "shape", "field", "bookmark", "note", "comment"];
+function validateDocxSelection(operation, options) {
+  if (operation.startsWith("model.")) return;
+  const has = (name) => options[name] !== void 0;
+  const reject = (message) => {
+    throw new DocxUsageError(message);
+  };
+  if (operation === "diff" && (options.mode === void 0 || ["parts", "xml"].includes(options.mode)) !== ((options.scope ?? (options.mode === "text" || options.mode === "structure" ? "body" : "package")) === "package")) reject("Package comparison modes require package scope; logical modes require a story scope.");
+  const pieces = operation.split(".");
+  const resource = pieces[0];
+  const action = pieces.at(-1);
+  const target = resourceSelectors[resource];
+  const token = has("select");
+  if (operation === "runs.set" && has("paragraph") && !has("run") && !token && options.all === void 0) {
+    options.all = true;
+  }
+  const all = options.all === true;
+  const selected = ordinalSelectors.filter(has);
+  if ((has("comment") || has("note")) && has("section")) reject("Annotation stories cannot be selected through a section.");
+  if (has("table") && (has("paragraph") || has("run")) && !has("cell")) reject("Paragraph selection inside a table requires a cell.");
+  if (["sections", "headers", "footers"].includes(resource) && selected.some((key) => key !== "section")) reject("Section resources reject descendant selectors.");
+  if (resource === "sections" && has("scope")) reject("Sections are package-global resources.");
+  if (["styles", "properties", "settings", "signatures", "custom-xml", "glossary"].includes(resource) && (selected.length || token || has("scope"))) reject("Global resources reject story selectors.");
+  if (all && operation !== "text.replace" && operation !== "lorem.set" && operation !== "revisions.add" && !["controls.repeat", "controls.bind"].includes(operation) && !["set", "remove", "accept", "reject"].includes(action)) reject("All is not applicable to this operation.");
+  if (["headers", "footers"].includes(resource) && ["get", "set", "remove"].includes(action) && !has("section") && !token)
+    reject("Header and footer access requires a section.");
+  if (target && ["get", "set", "remove", "replace", "accept", "reject", "repeat", "bind", "merge", "split"].includes(action) && !has(target) && !token && !all) reject(`A resource selection is required. Use --select TOKEN or --${target} N; see docx help ${pieces.join(" ")} for owner selectors.`);
+  if (resource === "tables" && pieces.length === 3 && !has("table") && !token)
+    reject("Row and column operations require a table.");
+  if (operation === "tables.split" && !has("cell") && !token) reject("Table split requires a cell.");
+  if (action === "add" && ["runs", "links", "fields", "toc", "captions", "notes", "equations"].includes(resource) && !has("paragraph") && !token)
+    reject("Inline insertion requires a paragraph.");
+  if (operation === "images.add") {
+    if (["run", "image", "link", "control", "revision", "shape", "field", "bookmark"].some(has)) reject("Image insertion requires a whole paragraph or block container.");
+    if (!token && ["headers", "footers"].includes(options.scope) && !has("section")) reject("Image insertion in a header or footer requires an explicit owner.");
+    if (!token && ["footnotes", "endnotes"].includes(options.scope) && !has("note")) reject("Image insertion in a note requires an explicit owner.");
+    if (!token && options.scope === "comments" && !has("comment")) reject("Image insertion in a comment requires an explicit owner.");
+  }
+  if (operation === "equations.replace" && !token) reject("Equation replacement requires a location token.");
+  if (["controls.list", "controls.set", "controls.repeat", "controls.bind"].includes(operation) && token) {
+    let range;
+    try {
+      range = decodeLocation(options.select).range;
+    } catch {
+      reject("Invalid control selection token.");
+    }
+    if (range !== null) reject("Control operations require whole control or owner tokens.");
+  }
+  if (["revisions.accept", "revisions.reject"].includes(operation) && token) {
+    let range;
+    try {
+      range = decodeLocation(options.select).range;
+    } catch {
+      reject("Invalid revision selection token.");
+    }
+    if (range !== null) reject("Revision decisions require a whole revision token.");
+  }
+  if (operation === "revisions.add") {
+    if (!token) {
+      if (!has("paragraph") && !has("run") && !all) reject("Tracked creation requires a paragraph or run selection, or explicit all scope.");
+    } else {
+      let range;
+      try {
+        range = decodeLocation(options.select).range;
+      } catch {
+        reject("Invalid tracked selection token.");
+      }
+      if (range && (options.kind === "insert" ? range.start !== range.end : range.start === range.end))
+        reject("Tracked insertion requires a caret; deletion requires nonempty text.");
+    }
+  }
+  if (["bookmarks.add", "comments.add"].includes(operation)) {
+    if (!token) reject("Range insertion requires a location token.");
+    let range;
+    try {
+      range = decodeLocation(options.select).range;
+    } catch {
+      reject("Invalid range selection token.");
+    }
+    if (!range || range.start === range.end)
+      reject("A nonempty text range is required.");
+  }
+}
+
+export {
+  validateDocxSelection
+};

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

@@ -0,0 +1,127 @@
+import {
+  loadShared
+} from "./chunk-RAXJVM4U.js";
+import {
+  writePackageArchive
+} from "./chunk-YRNBIU5U.js";
+import {
+  readBinary
+} from "./chunk-TL3KDYEM.js";
+import {
+  parseContentTypes
+} from "./chunk-N74TJL6X.js";
+import {
+  asciiKey,
+  partName
+} from "./chunk-XXFHTGV2.js";
+import {
+  OfficeError
+} from "./chunk-RR6QQ25D.js";
+
+// packages/safe-bash-presentation-engine/src/package-tools.ts
+import { sha256 } from "@noble/hashes/sha2.js";
+function record(value, allowed) {
+  if (!value || typeof value !== "object" || ![Object.prototype, null].includes(Object.getPrototypeOf(value)) || Reflect.ownKeys(value).some((key) => typeof key !== "string" || !allowed.includes(key) || !("value" in Object.getOwnPropertyDescriptor(value, key))))
+    throw new OfficeError("invalid-value", "Expected a plain package record.", "usage");
+}
+function list(value, maximum) {
+  if (!Array.isArray(value)) throw new OfficeError("invalid-value", "Expected package members.", "usage");
+  if (value.length > maximum) throw new OfficeError("resource-limit", "Package member limit exceeded.", "usage");
+  if (Object.getPrototypeOf(value) !== Array.prototype || Reflect.ownKeys(value).length !== value.length + 1 || Array.from({ length: value.length }, (_, index) => Object.getOwnPropertyDescriptor(value, String(index))).some((item) => !item || !("value" in item)))
+    throw new OfficeError("invalid-value", "Expected a dense package array.", "usage");
+}
+function digest(bytes) {
+  return Array.from(sha256(bytes), (byte) => byte.toString(16).padStart(2, "0")).join("");
+}
+async function extractPackage(input, context, options = {}) {
+  record(options, ["parts"]);
+  if (!context?.archiveLimits) throw new OfficeError("invalid-value", "Explicit limits are required.", "usage");
+  if (options.parts !== void 0) list(options.parts, context.archiveLimits.maxMembers);
+  if (!options || Object.keys(options).some((key) => key !== "parts") || options.parts !== void 0 && (!Array.isArray(options.parts) || !options.parts.length))
+    throw new OfficeError("invalid-value", "Invalid package extraction options.", "usage");
+  const selected = options.parts?.map((part) => {
+    const canonical = partName(part, false);
+    if (canonical !== part) throw new OfficeError("unsafe-path", "A canonical package part is required.", "usage");
+    return canonical;
+  });
+  if (selected && new Set(selected.map(asciiKey)).size !== selected.length)
+    throw new OfficeError("invalid-value", "Duplicate extracted part.", "usage");
+  const { reader } = await loadShared(input, context, false);
+  const types = parseContentTypes(reader.get("/[Content_Types].xml"), {
+    maxBytes: context.xmlLimits.maxBytes,
+    maxEntries: context.archiveLimits.maxMembers
+  });
+  const names = selected ?? [...reader.names].sort();
+  return Object.freeze(names.map((part, index) => {
+    const bytes = reader.get(part);
+    const contentType = part === "/[Content_Types].xml" ? "application/xml" : types.get(part);
+    const essence = contentType.split(";", 1)[0].trim().toLowerCase();
+    const extension = essence === "application/xml" || essence === "text/xml" || essence.endsWith("+xml") ? "xml" : { "image/png": "png", "image/jpeg": "jpg", "image/gif": "gif", "image/tiff": "tif", "image/bmp": "bmp", "audio/mpeg": "mp3", "video/mp4": "mp4" }[essence] ?? "bin";
+    return Object.freeze({ part, name: `part-${String(index + 1).padStart(6, "0")}.${extension}`, contentType, sha256: digest(bytes), bytes });
+  }));
+}
+async function packPackage(members, context, options = {}) {
+  record(options, ["kind"]);
+  if (!context?.limits || !context.archiveLimits || !Array.isArray(members) || !members.length || !options || Object.keys(options).some((key) => key !== "kind") || options.kind !== void 0 && !["pptx", "potx", "ppsx"].includes(options.kind))
+    throw new OfficeError("invalid-value", "Explicit package members and limits are required.", "usage");
+  if (context.signal?.aborted) throw new OfficeError("cancelled", "Operation cancelled.", "admit");
+  if (members.length > context.archiveLimits.maxMembers)
+    throw new OfficeError("resource-limit", "Package member limit exceeded.", "admit");
+  list(members, context.archiveLimits.maxMembers);
+  const names = /* @__PURE__ */ new Set();
+  const parents = /* @__PURE__ */ new Set();
+  let ownedTotal = 0;
+  const admitted = members.map((member) => {
+    record(member, ["part", "sha256", "bytes", "name", "contentType"]);
+    if (!member || typeof member.sha256 !== "string" || member.sha256.length !== 64 || [...member.sha256].some((character) => !"0123456789abcdef".includes(character)))
+      throw new OfficeError("invalid-value", "A lowercase SHA-256 digest is required.", "usage");
+    const part = partName(member.part, false);
+    if (part !== member.part || part.includes(":"))
+      throw new OfficeError("unsafe-path", "A canonical package part is required.", "usage");
+    const key = asciiKey(part);
+    if (names.has(key) || parents.has(key))
+      throw new OfficeError("invalid-opc", "Colliding package members.", "admit");
+    let parent = key.slice(0, key.lastIndexOf("/"));
+    while (parent) {
+      if (names.has(parent)) throw new OfficeError("invalid-opc", "Colliding package members.", "admit");
+      parents.add(parent);
+      parent = parent.slice(0, parent.lastIndexOf("/"));
+    }
+    names.add(key);
+    let input = member.bytes;
+    if (input instanceof Uint8Array) {
+      ownedTotal += input.length;
+      if (input.length > context.archiveLimits.maxEntryBytes || input.length > context.limits.maxBytes || ownedTotal > context.archiveLimits.maxTotalBytes)
+        throw new OfficeError("resource-limit", "Package byte limit exceeded.", "admit");
+      input = new Uint8Array(input);
+    }
+    return { part, sha256: member.sha256, input };
+  });
+  let total = 0;
+  const output = [];
+  for (const member of admitted) {
+    const remaining = context.archiveLimits.maxTotalBytes - total;
+    const bytes2 = await readBinary(member.input, context, { maxBytes: Math.min(context.limits.maxBytes, context.archiveLimits.maxEntryBytes, Math.max(1, remaining)) });
+    if (bytes2.length > remaining) throw new OfficeError("resource-limit", "Package byte limit exceeded.", "admit");
+    total += bytes2.length;
+    if (digest(bytes2) !== member.sha256)
+      throw new OfficeError("invalid-value", "Package member digest does not match.", "admit");
+    const name = [...member.part.slice(1)].map((character) => character.codePointAt(0) > 127 ? encodeURIComponent(character) : character).join("");
+    output.push({ name, bytes: bytes2 });
+  }
+  const bytes = await writePackageArchive(output, context, { compression: "store" });
+  const loaded = await loadShared(bytes, context);
+  if (options.kind !== void 0) {
+    const types = parseContentTypes(loaded.reader.get("/[Content_Types].xml"), {
+      maxBytes: context.xmlLimits.maxBytes,
+      maxEntries: context.archiveLimits.maxMembers
+    });
+    types.presentationKind(loaded.main, options.kind);
+  }
+  return bytes;
+}
+
+export {
+  extractPackage,
+  packPackage
+};

package/dist/safe-bash/command-chunks/{chunk-B5F2KQYA.js → chunk-SWUVHT7G.js}

@@ -1,6 +1,6 @@
 import {
   commandLimits
-} from "./chunk-MRFW2E6B.js";
+} from "./chunk-457CU3IC.js";
 
 // packages/safe-bash-command-node/src/commands/node/buffer.ts
 import { byteLength, decodeBytes, encodeBytes, isByteEncoding } from "../../safe-bash-io-engine/byte-encoding.js";

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

@@ -0,0 +1,38 @@
+// packages/safe-bash-docx-engine/src/protection.ts
+function activeSettingsProtection(root, view, budget) {
+  const result = /* @__PURE__ */ new Set();
+  for (const item of view.content) {
+    budget.charge("work", 1);
+    if (!("source" in item) || item.source !== root || item.disposition !== "understood") continue;
+    for (const child of item.content) {
+      budget.charge("work", 1);
+      if ("source" in child && child.disposition === "understood" && child.source.namespace === root.namespace && ["documentProtection", "writeProtection"].includes(child.source.localName)) {
+        budget.charge("retainedBytes", 16);
+        result.add(child.source);
+      }
+    }
+  }
+  return result;
+}
+function activeControlLocks(root, view, budget) {
+  const result = /* @__PURE__ */ new Map();
+  const stack = view.content.map((item) => ({ item, parent: void 0, grandparent: void 0 }));
+  while (stack.length) {
+    budget.charge("work", 1);
+    const { item, parent, grandparent } = stack.pop();
+    if (!("source" in item) || item.disposition !== "understood") continue;
+    const node = item.source;
+    if (node.namespace === root.namespace && node.localName === "lock" && parent?.namespace === root.namespace && parent.localName === "sdtPr" && grandparent?.namespace === root.namespace && grandparent.localName === "sdt") {
+      budget.charge("retainedBytes", 64);
+      result.set(node, { owner: grandparent, properties: parent });
+    }
+    budget.charge("retainedBytes", item.content.length * 24);
+    for (const child of item.content) stack.push({ item: child, parent: node, grandparent: parent });
+  }
+  return result;
+}
+
+export {
+  activeSettingsProtection,
+  activeControlLocks
+};