@poe-platform/safe-bash 0.1.806 → 0.1.807

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

@@ -0,0 +1,62 @@
+import {
+  acquireDocumentTransportInput
+} from "./chunk-ZXKOMB24.js";
+import {
+  contextData,
+  modelContext
+} from "./chunk-2W54TAGI.js";
+import {
+  validateDocxValue
+} from "./chunk-R4TYL2G6.js";
+import {
+  DocxUsageError
+} from "./chunk-2P7BLWWI.js";
+
+// packages/safe-bash-docx-engine/src/model-transport-context.ts
+async function resolveDocumentModelContext(value, host = {}) {
+  const settings = modelContext(host);
+  if (value === void 0) return settings;
+  const data = contextData(value, [
+    "vfs",
+    "limits",
+    "timestamp",
+    "author",
+    "fonts",
+    "template"
+  ]);
+  const record = {
+    ...data,
+    ...data.limits === void 0 ? {} : { limits: contextData(data.limits) },
+    ...data.template === void 0 ? {} : { template: contextData(data.template) }
+  };
+  if (!validateDocxValue("DocumentContext", record))
+    throw new DocxUsageError("Expected declarative document context.");
+  if (record.vfs !== void 0 && record.vfs !== settings.binaryResolver?.capability)
+    throw new DocxUsageError("Unknown VFS capability token.");
+  if (record.fonts !== void 0 && record.fonts !== settings.fontResolver?.capability)
+    throw new DocxUsageError("Unknown font capability token.");
+  if (record.template !== void 0 && settings.template !== void 0)
+    throw new DocxUsageError("Conflicting context templates.");
+  const { template, ...base } = settings;
+  const budget = settings.budget.lower(record.limits ?? {}, settings.signal);
+  const selected = modelContext({
+    ...base,
+    budget,
+    limits: {
+      ...settings.limits,
+      maxEntryBytes: Math.min(settings.limits.maxEntryBytes, budget.limits.xmlPartBytes),
+      maxDepth: Math.min(settings.limits.maxDepth, budget.limits.xmlDepth)
+    },
+    ...record.author === void 0 ? {} : { author: record.author },
+    ...record.timestamp === void 0 ? {} : { timestamp: new Date(record.timestamp) },
+    ...record.vfs === void 0 ? {} : { vfs: { open: settings.binaryResolver.open } },
+    ...record.fonts === void 0 ? {} : { fonts: settings.fontResolver.fonts }
+  });
+  const bytes = record.template === void 0 ? template : await acquireDocumentTransportInput(record.template, selected);
+  selected.budget.check("work", 0);
+  return bytes === void 0 ? selected : modelContext({ ...selected, template: bytes });
+}
+
+export {
+  resolveDocumentModelContext
+};

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

@@ -0,0 +1,92 @@
+// packages/safe-bash-presentation-engine/src/selector-schema.ts
+var selectionQuerySchema = {
+  $schema: "https://json-schema.org/draft/2020-12/schema",
+  title: "Presentation selection query version 1",
+  type: "object",
+  additionalProperties: false,
+  properties: {
+    kind: { enum: ["slide", "part", "object"] },
+    scope: {
+      enum: [
+        "slides",
+        "notes",
+        "layouts",
+        "masters",
+        "notes-master",
+        "handout-master",
+        "presentation",
+        "shared"
+      ]
+    },
+    owner: { type: "string", minLength: 1 },
+    id: { type: "string", minLength: 1 },
+    name: { type: "string" },
+    part: { type: "string", minLength: 1 },
+    token: {
+      type: "string",
+      minLength: 1,
+      description: "Canonical identity token emitted by inspection; validated against admitted bytes."
+    },
+    all: { type: "boolean" },
+    position: {
+      oneOf: [
+        {
+          type: "object",
+          additionalProperties: false,
+          required: ["coordinateSystem", "value"],
+          properties: {
+            coordinateSystem: { const: "one-based" },
+            value: { type: "integer", minimum: 1, maximum: 9007199254740991 }
+          }
+        },
+        {
+          type: "object",
+          additionalProperties: false,
+          required: ["coordinateSystem", "value"],
+          properties: {
+            coordinateSystem: { const: "zero-based" },
+            value: { type: "integer", minimum: 0, maximum: 9007199254740991 }
+          }
+        }
+      ]
+    }
+  },
+  oneOf: [
+    {
+      required: ["token"],
+      not: {
+        anyOf: ["scope", "owner", "position", "id", "name", "part", "all"].map((key) => ({
+          required: [key]
+        }))
+      }
+    },
+    {
+      required: ["kind"],
+      not: { required: ["token"] },
+      allOf: [
+        { if: { properties: { kind: { const: "object" } } }, then: { required: ["owner"] } },
+        {
+          if: { properties: { kind: { const: "slide" } } },
+          then: { properties: { scope: { const: "slides" } } }
+        },
+        { if: { required: ["part"] }, then: { properties: { kind: { const: "part" } } } },
+        {
+          not: {
+            anyOf: [
+              ["position", "id"],
+              ["position", "name"],
+              ["position", "part"],
+              ["id", "name"],
+              ["id", "part"],
+              ["name", "part"]
+            ].map((required) => ({ required }))
+          }
+        }
+      ]
+    }
+  ]
+};
+
+export {
+  selectionQuerySchema
+};

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

@@ -0,0 +1,366 @@
+import {
+  cleanupCommentAuthors
+} from "./chunk-S4OBYRNI.js";
+import {
+  writePackageArchive
+} from "./chunk-YRNBIU5U.js";
+import {
+  SelectionError,
+  readSelectionIndex
+} from "./chunk-CKEODJVT.js";
+import {
+  readPackage
+} from "./chunk-FRZ5P5AB.js";
+import {
+  readBinary
+} from "./chunk-TL3KDYEM.js";
+import {
+  validatePresentation
+} from "./chunk-XDEA3TL5.js";
+import {
+  parseXmlPart
+} from "./chunk-L3WY5ASN.js";
+import {
+  parseContentTypes
+} from "./chunk-N74TJL6X.js";
+import {
+  readRelationshipGraph
+} from "./chunk-5GEFJROP.js";
+import {
+  asciiKey
+} from "./chunk-XXFHTGV2.js";
+import {
+  OfficeError
+} from "./chunk-RR6QQ25D.js";
+
+// packages/safe-bash-presentation-engine/src/slide-removal.ts
+var sectionNamespace = "http://schemas.microsoft.com/office/powerpoint/2010/main";
+var dialects = [
+  {
+    p: "http://schemas.openxmlformats.org/presentationml/2006/main",
+    a: "http://schemas.openxmlformats.org/drawingml/2006/main",
+    r: "http://schemas.openxmlformats.org/officeDocument/2006/relationships"
+  },
+  {
+    p: "http://purl.oclc.org/ooxml/presentationml/main",
+    a: "http://purl.oclc.org/ooxml/drawingml/main",
+    r: "http://purl.oclc.org/ooxml/officeDocument/relationships"
+  }
+];
+function attr(node, localName, namespace = "") {
+  return node.attributes.find(
+    (a) => a.name.localName === localName && a.name.namespace === namespace
+  )?.value;
+}
+function relPart(owner) {
+  const slash = owner.lastIndexOf("/");
+  return `${owner.slice(0, slash)}/_rels/${owner.slice(slash + 1)}.rels`;
+}
+function dangling() {
+  throw new OfficeError(
+    "dangling-reference",
+    "Slide removal has unresolved references or requires an explicit removal policy.",
+    "validate-intent"
+  );
+}
+function prune(document, removed) {
+  const paths = [];
+  const visit = (node, path) => {
+    if (removed.has(node)) {
+      paths.push(path);
+      return;
+    }
+    node.children.forEach((child, i) => visit(child, [...path, i]));
+  };
+  visit(document.root, []);
+  for (const path of paths.reverse()) {
+    let parent = document.root;
+    for (const i of path.slice(0, -1)) parent = parent.children[i];
+    document = document.spliceChildren(parent, path.at(-1), 1, []);
+  }
+  return document;
+}
+async function removeSlides(input, options, context) {
+  if (!options || typeof options !== "object" || ![Object.prototype, null].includes(Object.getPrototypeOf(options)) || Object.keys(options).some(
+    (key) => !["selection", "allowEmpty", "referencePolicy"].includes(key)
+  ) || options.referencePolicy !== void 0 && options.referencePolicy !== "remove" || options.allowEmpty !== void 0 && typeof options.allowEmpty !== "boolean")
+    throw new OfficeError("invalid-value", "Invalid slide removal options.", "usage");
+  if (!context?.xmlLimits || !context.relationshipLimits)
+    throw new OfficeError(
+      "invalid-value",
+      "Explicit XML and relationship limits are required.",
+      "usage"
+    );
+  const queries = Array.isArray(options.selection) ? options.selection : [options.selection];
+  if (!queries.length) throw new SelectionError("invalid-selection");
+  if (queries.length > context.relationshipLimits.maxParts)
+    throw new OfficeError("resource-limit", "Too many slide selections.", "usage");
+  for (const q of queries)
+    if (!q || typeof q !== "object" || q.kind !== void 0 && q.kind !== "slide" || q.scope !== void 0 && q.scope !== "slides" || !q.all && q.token === void 0 && q.id === void 0 && q.name === void 0 && q.position === void 0)
+      throw new SelectionError("invalid-selection");
+  const source = await readBinary(input, context);
+  const reader = await readPackage(source, context);
+  const limits = {
+    ...context.xmlLimits,
+    ...context.relationshipLimits,
+    maxBytes: Math.min(context.xmlLimits.maxBytes, context.relationshipLimits.maxBytes),
+    maxEntries: context.archiveLimits.maxMembers
+  };
+  const types = parseContentTypes(reader.get("/[Content_Types].xml"), limits);
+  const graph = readRelationshipGraph(reader, context.relationshipLimits);
+  for (const name of reader.names) {
+    if (name === "/[Content_Types].xml") continue;
+    const type = types.get(name).toLowerCase();
+    if (type.includes("digital-signature") || type.includes("macroenabled") || type.includes("vbaproject") || asciiKey(name).startsWith("/_xmlsignatures/"))
+      throw new OfficeError(
+        "unsupported-edit",
+        "Signed and macro-enabled packages cannot be changed.",
+        "validate-intent"
+      );
+  }
+  for (const owner of ["/", ...graph.parts])
+    if (graph.outgoing(owner).some(
+      (edge) => edge.type.includes("/digital-signature/") || edge.type.endsWith("/vbaProject")
+    ))
+      throw new OfficeError(
+        "unsupported-edit",
+        "Signed and macro-enabled packages cannot be changed.",
+        "validate-intent"
+      );
+  if (!validatePresentation(reader, limits).valid)
+    throw new OfficeError(
+      "invalid-opc",
+      "Slide removal requires a valid presentation graph.",
+      "validate-intent"
+    );
+  const index = await readSelectionIndex(source, context);
+  const ids = /* @__PURE__ */ new Set(), slides = /* @__PURE__ */ new Set();
+  for (const query of queries) {
+    try {
+      for (const record of index.select(query)) {
+        if (record.kind !== "slide" || ids.has(record.id))
+          throw new SelectionError("invalid-selection");
+        ids.add(record.id);
+        slides.add(record.part);
+      }
+    } catch (error) {
+      if (!(error instanceof SelectionError && error.code === "missing-selection" && options.allowEmpty))
+        throw error;
+    }
+  }
+  const main = graph.outgoing("/").find((edge) => dialects.some((d2) => edge.type === `${d2.r}/officeDocument`)).targetPart;
+  const presentation = parseXmlPart(reader.get(main), context.xmlLimits);
+  const d = dialects.find((value) => value.p === presentation.root.name.namespace);
+  const deleted = new Set(slides);
+  for (const part of slides)
+    for (const edge of graph.outgoing(part)) {
+      if (edge.targetPart && ["notesSlide", "comments"].some((kind) => edge.type === `${d.r}/${kind}`) && types.get(edge.targetPart) === `application/vnd.openxmlformats-officedocument.presentationml.${edge.type.endsWith("/comments") ? "comments" : "notesSlide"}+xml`)
+        deleted.add(edge.targetPart);
+    }
+  let changed = true;
+  while (changed) {
+    changed = false;
+    for (const part of deleted)
+      if (!slides.has(part) && graph.incoming(part).some((edge) => !deleted.has(edge.owner))) {
+        deleted.delete(part);
+        changed = true;
+      }
+  }
+  const removedEdges = /* @__PURE__ */ new Map();
+  for (const part of deleted)
+    for (const edge of graph.incoming(part)) {
+      if (deleted.has(edge.owner)) continue;
+      if (edge.owner !== main || edge.type !== `${d.r}/slide` || !slides.has(part)) {
+        if (!slides.has(part) || edge.type !== `${d.r}/slide` || options.referencePolicy !== "remove")
+          dangling();
+      }
+      const set = removedEdges.get(edge.owner) ?? /* @__PURE__ */ new Set();
+      set.add(edge.id);
+      removedEdges.set(edge.owner, set);
+    }
+  const mainEdges = removedEdges.get(main) ?? /* @__PURE__ */ new Set();
+  const changes = /* @__PURE__ */ new Map();
+  for (const part of graph.parts) {
+    context.signal?.throwIfAborted();
+    if (deleted.has(part)) continue;
+    const type = types.get(part);
+    const edges = removedEdges.get(part) ?? /* @__PURE__ */ new Set();
+    if (!type.endsWith("+xml") && type !== "application/xml" && type !== "text/xml") {
+      if (edges.size) dangling();
+      continue;
+    }
+    const document = part === main ? presentation : parseXmlPart(reader.get(part), context.xmlLimits);
+    const removed = /* @__PURE__ */ new Set();
+    const references = /* @__PURE__ */ new Set();
+    const visit = (node, parent) => {
+      const ns = node.name.namespace, local = node.name.localName;
+      if (ns === d.p && local === "modifyVerifier")
+        throw new OfficeError(
+          "unsupported-edit",
+          "Protected presentations cannot be changed.",
+          "validate-intent"
+        );
+      if (!slides.size) {
+        node.children.forEach((child) => visit(child, node));
+        return;
+      }
+      if ([d.p, d.a].includes(document.root.name.namespace)) {
+        if (![d.p, d.a, sectionNamespace].includes(ns)) dangling();
+        for (const attribute of node.attributes)
+          if (attribute.name.namespace && ![
+            d.r,
+            "http://www.w3.org/XML/1998/namespace",
+            "http://schemas.openxmlformats.org/markup-compatibility/2006"
+          ].includes(attribute.name.namespace))
+            dangling();
+      }
+      if (ns === "http://schemas.openxmlformats.org/markup-compatibility/2006") dangling();
+      if (local === "ext" && (ns === d.p || ns === d.a && (parent?.name.localName === "extLst" || attr(node, "uri") !== void 0)) && !(ns === d.p && part === main && attr(node, "uri") === "{521415D9-36F7-43E2-AB2F-B90AF26B5E84}" && node.children.length === 1 && node.children[0].name.namespace === sectionNamespace && node.children[0].name.localName === "sectionLst"))
+        dangling();
+      if (ns === sectionNamespace) {
+        const structure = {
+          sectionLst: { parent: "ext", child: "section", attributes: [] },
+          section: { parent: "sectionLst", child: "sldIdLst", attributes: ["name", "id"] },
+          sldIdLst: { parent: "section", child: "sldId", attributes: [] },
+          sldId: { parent: "sldIdLst", attributes: ["id"] }
+        };
+        const rule = structure[local];
+        if (part !== main || !rule || parent?.name.localName !== rule.parent || parent.name.namespace !== (local === "sectionLst" ? d.p : sectionNamespace) || node.children.some(
+          (child) => child.name.namespace !== sectionNamespace || child.name.localName !== rule.child
+        ) || node.attributes.some(
+          (attribute) => attribute.name.namespace || !rule.attributes.includes(attribute.name.localName)
+        ))
+          dangling();
+        if (local === "sldId" && !index.slides.some((slide) => slide.id === attr(node, "id")))
+          dangling();
+      }
+      if ((ns === d.a || ns === d.p) && local === "extLst" && node.children.length && !(part === main && ns === d.p && parent === document.root && node.children.every(
+        (child) => child.name.namespace === d.p && child.name.localName === "ext"
+      )))
+        dangling();
+      const relation = attr(node, "id", d.r);
+      if (part === main && ns === d.p && local === "sldId" && parent?.name.localName === "sldIdLst" && ids.has(attr(node, "id") ?? "")) {
+        removed.add(node);
+        if (relation) references.add(relation);
+        return;
+      }
+      const membership = part === main && (ns === d.p && local === "sld" && parent?.name.localName === "sldLst" && mainEdges.has(relation ?? "") || ns === sectionNamespace && local === "sldId" && ids.has(attr(node, "id") ?? ""));
+      if (membership) {
+        removed.add(node);
+        return;
+      }
+      for (const attribute of node.attributes)
+        if (attribute.name.namespace === d.r && edges.has(attribute.value)) {
+          if (ns !== d.a || !["hlinkClick", "hlinkHover", "hlinkMouseOver"].includes(local) || attribute.name.localName !== "id" || options.referencePolicy !== "remove")
+            dangling();
+          references.add(attribute.value);
+          removed.add(node);
+        }
+      const action = attr(node, "action");
+      if (action && ![
+        "ppaction://hlinkshowjump",
+        "ppaction://hlinksldjump",
+        "ppaction://customshow",
+        "ppaction://hlinkfile",
+        "ppaction://hlinkpres",
+        "ppaction://ole",
+        "ppaction://macro",
+        "ppaction://program",
+        "ppaction://media"
+      ].includes(action.split("?")[0]))
+        dangling();
+      if (action?.startsWith("ppaction://hlinkshowjump")) {
+        if (action !== "ppaction://hlinkshowjump?jump=endshow") {
+          const owner = index.slides.findIndex((slide) => slide.part === part);
+          const targets = {
+            "ppaction://hlinkshowjump?jump=firstslide": 0,
+            "ppaction://hlinkshowjump?jump=lastslide": index.slides.length - 1,
+            "ppaction://hlinkshowjump?jump=nextslide": owner + 1,
+            "ppaction://hlinkshowjump?jump=previousslide": owner - 1
+          };
+          const target = targets[action];
+          if (owner < 0 || target === void 0 || !index.slides[target]) dangling();
+          if (slides.has(index.slides[target].part)) {
+            if (options.referencePolicy !== "remove" || ns !== d.a || !["hlinkClick", "hlinkHover", "hlinkMouseOver"].includes(local))
+              dangling();
+            removed.add(node);
+          }
+        }
+      }
+      if (action && (action.startsWith("ppaction://customshow") || action.startsWith("ppaction://hlinksldjump") && (!relation || !graph.outgoing(part).some(
+        (edge) => edge.id === relation && edge.type === `${d.r}/slide` && !edge.external
+      ))))
+        dangling();
+      node.children.forEach((child) => visit(child, node));
+      if (node.children.length && node.children.every((child) => removed.has(child)) && (ns === sectionNamespace && ["sectionLst", "section", "sldIdLst"].includes(local) || ns === d.p && ["custShowLst", "custShow", "sldLst", "ext", "extLst"].includes(local)))
+        removed.add(node);
+    };
+    visit(document.root);
+    for (const edge of edges) if (!references.has(edge)) dangling();
+    if (removed.size) changes.set(part, prune(document, removed).bytes());
+  }
+  if (!slides.size) return source;
+  for (const [owner, ids2] of removedEdges) {
+    const name = relPart(owner);
+    const document = parseXmlPart(reader.get(name), context.xmlLimits);
+    changes.set(
+      name,
+      prune(
+        document,
+        new Set(document.root.children.filter((node) => ids2.has(attr(node, "Id") ?? "")))
+      ).bytes()
+    );
+  }
+  const manifest = parseXmlPart(reader.get("/[Content_Types].xml"), context.xmlLimits);
+  const deletedKeys = new Set([...deleted].map(asciiKey));
+  changes.set(
+    "/[Content_Types].xml",
+    prune(
+      manifest,
+      new Set(
+        manifest.root.children.filter(
+          (node) => node.name.localName === "Override" && deletedKeys.has(asciiKey(attr(node, "PartName") ?? ""))
+        )
+      )
+    ).bytes()
+  );
+  const removedAuthors = /* @__PURE__ */ new Set();
+  for (const part of deleted) {
+    if (types.get(part) !== "application/vnd.openxmlformats-officedocument.presentationml.comments+xml")
+      continue;
+    const document = parseXmlPart(reader.get(part), context.xmlLimits);
+    for (const node of document.root.children)
+      if (node.name.namespace === d.p && node.name.localName === "cm") {
+        const id = attr(node, "authorId");
+        if (id !== void 0) removedAuthors.add(id);
+      }
+  }
+  const authorEdges = graph.outgoing(main).filter((edge) => edge.type === `${d.r}/commentAuthors`);
+  if (authorEdges.length === 1 && !authorEdges[0].external)
+    cleanupCommentAuthors(
+      reader,
+      changes,
+      deleted,
+      removedAuthors,
+      d.p,
+      context.xmlLimits,
+      authorEdges[0].targetPart ?? void 0
+    );
+  for (const part of [...deleted]) deleted.add(relPart(part));
+  const output = await writePackageArchive(
+    reader.names.filter((name) => !deleted.has(name)).map((name) => ({ name: name.slice(1), bytes: changes.get(name) ?? reader.get(name) })),
+    context,
+    { compression: "auto", source }
+  );
+  if (!validatePresentation(await readPackage(output, context), limits).valid)
+    throw new OfficeError(
+      "invalid-opc",
+      "Removed slides fail graph validation.",
+      "validate-result"
+    );
+  return output;
+}
+
+export {
+  removeSlides
+};