@poe-platform/safe-bash 0.1.806 → 0.1.807

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

@@ -0,0 +1,183 @@
+import {
+  asciiKey,
+  partName
+} from "./chunk-XXFHTGV2.js";
+import {
+  OfficeError
+} from "./chunk-RR6QQ25D.js";
+
+// packages/safe-bash-presentation-engine/src/content-types.ts
+import { SaxesParser } from "saxes";
+var mainKinds = Object.freeze({
+  "application/vnd.openxmlformats-officedocument.presentationml.presentation.main+xml": "pptx",
+  "application/vnd.openxmlformats-officedocument.presentationml.template.main+xml": "potx",
+  "application/vnd.openxmlformats-officedocument.presentationml.slideshow.main+xml": "ppsx"
+});
+function invalid() {
+  throw new OfficeError("invalid-opc", "Invalid package content types.", "index");
+}
+function token(character) {
+  const code = character.charCodeAt(0);
+  return code >= 48 && code <= 57 || code >= 65 && code <= 90 || code >= 97 && code <= 122 || "!#$%&'*+-.^_`|~".includes(character);
+}
+function mediaType(value) {
+  let position = 0;
+  const readToken = () => {
+    const start = position;
+    while (position < value.length && token(value[position])) position++;
+    if (position === start) invalid();
+    return value.slice(start, position);
+  };
+  readToken();
+  if (value[position++] !== "/") invalid();
+  readToken();
+  const essence = asciiKey(value.slice(0, position));
+  const parameters = /* @__PURE__ */ new Set();
+  while (position < value.length) {
+    while (value[position] === " " || value[position] === "	") position++;
+    if (value[position++] !== ";") invalid();
+    while (value[position] === " " || value[position] === "	") position++;
+    const name = asciiKey(readToken());
+    if (parameters.has(name) || value[position++] !== "=") invalid();
+    parameters.add(name);
+    if (value[position] !== '"') {
+      readToken();
+    } else {
+      position++;
+      let closed = false;
+      while (position < value.length) {
+        let character = value[position++];
+        if (character === '"') {
+          closed = true;
+          break;
+        }
+        if (character === "\\") {
+          if (position === value.length) invalid();
+          character = value[position++];
+        }
+        const code = character.charCodeAt(0);
+        if (code < 32 && code !== 9 || code === 127 || code > 255) invalid();
+      }
+      if (!closed) invalid();
+    }
+  }
+  if (parameters.size && (essence.startsWith("application/vnd.openxmlformats-package.") || Object.hasOwn(mainKinds, essence)))
+    invalid();
+  return essence;
+}
+function parseContentTypes(bytes, settings = {}) {
+  const limits = { maxBytes: Infinity, maxEntries: Infinity, ...settings };
+  if (!(bytes instanceof Uint8Array))
+    throw new OfficeError("invalid-type", "Expected content-type bytes.", "usage");
+  if (!limits || limits.maxBytes !== Infinity && !Number.isSafeInteger(limits.maxBytes) || limits.maxBytes < 1 || limits.maxEntries !== Infinity && !Number.isSafeInteger(limits.maxEntries) || limits.maxEntries < 1) {
+    throw new OfficeError("invalid-value", "Explicit content-type limits are required.", "usage");
+  }
+  const maxEntries = limits.maxEntries;
+  if (bytes.length > limits.maxBytes)
+    throw new OfficeError("resource-limit", "Content-type byte limit exceeded.", "index");
+  const overrides = /* @__PURE__ */ new Map();
+  const defaults = /* @__PURE__ */ new Map();
+  let encoding = "utf-8";
+  if (bytes[0] === 255 && bytes[1] === 254 || bytes[0] === 60 && bytes[1] === 0)
+    encoding = "utf-16le";
+  if (bytes[0] === 254 && bytes[1] === 255 || bytes[0] === 0 && bytes[1] === 60)
+    encoding = "utf-16be";
+  try {
+    const xml = new TextDecoder(encoding, { fatal: true }).decode(bytes);
+    const parser = new SaxesParser({ xmlns: true });
+    let depth = 0;
+    let count = 0;
+    parser.on("error", invalid);
+    parser.on("doctype", invalid);
+    parser.on("xmldecl", (declaration) => {
+      if (declaration.version !== "1.0") invalid();
+      if (declaration.encoding && asciiKey(declaration.encoding) !== (encoding === "utf-8" ? "utf-8" : "utf-16"))
+        invalid();
+    });
+    parser.on("text", (value) => {
+      if ([...value].some((character) => !" 	\n\r".includes(character))) invalid();
+    });
+    parser.on("cdata", invalid);
+    parser.on("opentag", (tag) => {
+      depth++;
+      if (tag.uri !== "http://schemas.openxmlformats.org/package/2006/content-types" || depth > 2)
+        invalid();
+      const attributes = Object.values(tag.attributes).filter(
+        (attribute) => attribute.uri !== "http://www.w3.org/2000/xmlns/"
+      );
+      if (depth === 1) {
+        if (tag.local !== "Types" || attributes.length) invalid();
+        return;
+      }
+      if (++count > maxEntries)
+        throw new OfficeError("resource-limit", "Content-type entry limit exceeded.", "index");
+      const isDefault = tag.local === "Default";
+      if (!isDefault && tag.local !== "Override") invalid();
+      const nameAttribute = isDefault ? "Extension" : "PartName";
+      if (attributes.length !== 2 || attributes.some(
+        (attribute) => attribute.uri || attribute.local !== nameAttribute && attribute.local !== "ContentType"
+      ))
+        invalid();
+      const name = attributes.find((attribute) => attribute.local === nameAttribute)?.value;
+      const type = attributes.find((attribute) => attribute.local === "ContentType")?.value;
+      if (!name || !type) invalid();
+      mediaType(type);
+      let key;
+      if (isDefault) {
+        for (let index = 0; index < name.length; index++) {
+          const character = name[index];
+          if (character === "%") {
+            const hex = name.slice(index + 1, index + 3);
+            if (hex.length !== 2 || [...hex].some((digit) => !"0123456789abcdefABCDEF".includes(digit)))
+              invalid();
+            index += 2;
+          } else {
+            const code = character.charCodeAt(0);
+            if (!(code >= 48 && code <= 57 || code >= 65 && code <= 90 || code >= 97 && code <= 122 || "!$&'()*+,:=@-_~".includes(character)))
+              invalid();
+          }
+        }
+        key = asciiKey(name);
+      } else {
+        key = asciiKey(partName(name, false));
+        if (key === "/[content_types].xml") invalid();
+      }
+      const entries = isDefault ? defaults : overrides;
+      if (entries.has(key)) invalid();
+      entries.set(key, type);
+    });
+    parser.on("closetag", () => {
+      depth--;
+    });
+    parser.write(xml).close();
+    if (!count) invalid();
+  } catch (error) {
+    if (error instanceof OfficeError) throw error;
+    invalid();
+  }
+  const get = (part) => {
+    if (typeof part !== "string")
+      throw new OfficeError("invalid-type", "Expected a part URI string.", "usage");
+    const name = partName(part, false);
+    const key = asciiKey(name);
+    if (key === "/[content_types].xml") invalid();
+    const filename = name.slice(name.lastIndexOf("/") + 1);
+    const dot = filename.lastIndexOf(".");
+    const type = overrides.get(key) ?? (dot < 0 ? void 0 : defaults.get(asciiKey(filename.slice(dot + 1))));
+    if (!type) throw new OfficeError("missing-binding", "Part content type is absent.", "index");
+    return type;
+  };
+  return Object.freeze({
+    get,
+    presentationKind(mainPart, expectedKind) {
+      const essence = mediaType(get(mainPart));
+      const kind = Object.hasOwn(mainKinds, essence) ? mainKinds[essence] : void 0;
+      if (!kind || expectedKind !== void 0 && expectedKind !== kind) invalid();
+      return kind;
+    }
+  });
+}
+
+export {
+  parseContentTypes
+};

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

@@ -0,0 +1,304 @@
+import {
+  readImages
+} from "./chunk-GIESJLR2.js";
+import {
+  admitImage
+} from "./chunk-45BW6MGM.js";
+import {
+  attr,
+  child,
+  escape,
+  loadShared,
+  nextRel,
+  relPart
+} from "./chunk-RAXJVM4U.js";
+import {
+  SelectionError
+} from "./chunk-CKEODJVT.js";
+import {
+  asciiKey,
+  partName,
+  relativePartReference
+} from "./chunk-XXFHTGV2.js";
+import {
+  OfficeError
+} from "./chunk-RR6QQ25D.js";
+
+// packages/safe-bash-presentation-engine/src/image-replacement.ts
+function invalid(message) {
+  throw new OfficeError("invalid-value", message, "usage");
+}
+function fields(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))
+  ))
+    invalid("Invalid image replacement options.");
+}
+function nodes(root) {
+  return [root, ...root.children.flatMap(nodes)];
+}
+function binding(doc, occurrence, r, a, p) {
+  let position = 0;
+  let found;
+  const visit = (node, shape, fill) => {
+    if (node.name.namespace === p && ["pic", "sp", "cxnSp", "graphicFrame", "grpSp"].includes(node.name.localName))
+      shape = node;
+    if ([p, a].includes(node.name.namespace) && node.name.localName === "blipFill") fill = node;
+    if (node.name.namespace === a && node.name.localName === "blip" || node.name.namespace === "http://schemas.microsoft.com/office/drawing/2016/SVG/main" && node.name.localName === "svgBlip") {
+      for (const attribute of node.attributes.filter(
+        (x) => x.name.namespace === r && ["embed", "link"].includes(x.name.localName)
+      )) {
+        position++;
+        if (`${occurrence.sourcePart}#image-${position}-${attribute.name.localName}` === occurrence.id)
+          found = { node, attribute: attribute.name.localName, shape, fill };
+      }
+    }
+    for (const next of node.children) visit(next, shape, fill);
+  };
+  visit(doc.root);
+  if (!found) throw new SelectionError("missing-selection");
+  return found;
+}
+async function replaceImage(input, selector, bytes, options, context) {
+  context.signal?.throwIfAborted();
+  fields(options, [
+    "contentType",
+    "shared",
+    "all",
+    "allowEmpty",
+    "preserveCrop",
+    "preserveGeometry",
+    "preserveAltText",
+    "altText"
+  ]);
+  fields(selector, ["scope", "slide", "image", "select"]);
+  for (const key of [
+    "shared",
+    "all",
+    "allowEmpty",
+    "preserveCrop",
+    "preserveGeometry",
+    "preserveAltText"
+  ])
+    if (options[key] !== void 0 && typeof options[key] !== "boolean")
+      invalid("Image replacement policies require booleans.");
+  if (options.altText !== void 0 && typeof options.altText !== "string")
+    invalid("Image alt text requires text.");
+  if (selector.select !== void 0 && options.all !== void 0 || !options.all && selector.image === void 0 && selector.select === void 0 || selector.image !== void 0 && (!selector.scope || selector.scope === "slides") && selector.slide === void 0 || selector.scope === "shared" && !options.shared)
+    throw new SelectionError("invalid-selection");
+  if (!(bytes instanceof Uint8Array)) invalid("Image input requires bytes.");
+  if (bytes.byteLength > Math.min(context.limits.maxBytes, context.archiveLimits.maxEntryBytes))
+    throw new OfficeError("resource-limit", "Image exceeds the admitted byte budget.", "admit");
+  const metadata = admitImage(bytes, options.contentType);
+  bytes = new Uint8Array(bytes);
+  options = { ...options };
+  selector = { ...selector };
+  const s = await loadShared(input, context);
+  const selected = (await readImages(s.source, selector, context)).occurrences;
+  if (!selected.length) {
+    if (!options.allowEmpty) throw new SelectionError("missing-selection");
+    return { bytes: s.source, affected: 0, occurrences: [], affectedSlides: [] };
+  }
+  if (selected.length !== 1 && !options.all)
+    throw new SelectionError(
+      "ambiguous-selection",
+      selected.map((x) => x.location)
+    );
+  const all = (await readImages(s.source, { scope: "shared" }, context)).occurrences;
+  const oldParts = new Set(selected.map((x) => x.mediaPart));
+  const affected = options.shared ? all.filter((x) => oldParts.has(x.mediaPart)) : selected;
+  if (affected.some(
+    (x) => x.external || !x.mediaPart || x.role !== "primary" || x.contentType === "image/svg+xml"
+  ))
+    throw new OfficeError(
+      "unsupported-edit",
+      "Replacement requires embedded images without vector fallback bindings.",
+      "validate-intent"
+    );
+  if (options.shared && s.index.inventory.relationships.some(
+    (x) => x.targetPart && oldParts.has(x.targetPart) && x.type !== `${s.r}/image`
+  ))
+    throw new OfficeError(
+      "unsupported-edit",
+      "Shared media has an unsupported relationship consumer.",
+      "validate-intent"
+    );
+  const affectedSlides = s.index.inventory.slides.filter(
+    (slide) => affected.some(
+      (x) => x.sourcePart === slide.part || x.inheritedBy.includes(slide.position) || x.scope === "notes" && s.index.inventory.relationships.some(
+        (edge) => edge.owner === slide.part && edge.targetPart === x.sourcePart && edge.type === `${s.r}/notesSlide`
+      )
+    )
+  ).map((x) => x.position);
+  if (options.preserveCrop !== false && options.preserveGeometry !== false && options.preserveAltText !== false && affected.every((occurrence) => {
+    const original = s.reader.get(occurrence.mediaPart);
+    return occurrence.contentType === options.contentType && original.length === bytes.length && original.every((value, index) => value === bytes[index]) && (options.altText === void 0 || options.altText === occurrence.altText);
+  })) {
+    context.signal?.throwIfAborted();
+    return { bytes: s.source, affected: affected.length, occurrences: affected, affectedSlides };
+  }
+  if (affected.some(
+    (occurrence) => s.reader.names.some((name) => asciiKey(name) === asciiKey(relPart(occurrence.mediaPart)))
+  ))
+    throw new OfficeError(
+      "unsupported-edit",
+      "Image resources with owned relationships cannot be replaced.",
+      "validate-intent"
+    );
+  let width = 0, height = 0;
+  if (options.preserveGeometry === false) {
+    if (metadata.pixelWidth === null || metadata.pixelHeight === null)
+      invalid("Geometry reset requires intrinsic image dimensions.");
+    width = Math.round(metadata.pixelWidth * 914400 / metadata.dpiX);
+    height = Math.round(metadata.pixelHeight * 914400 / metadata.dpiY);
+    if ([width, height].some((x) => !Number.isSafeInteger(x) || x < 1 || x > 27273042316900))
+      invalid("Computed image geometry is outside the supported range.");
+  }
+  let mediaIndex = 1;
+  while (s.reader.names.some(
+    (name) => asciiKey(name) === `/ppt/media/image${mediaIndex}.${metadata.extension}`
+  ))
+    mediaIndex++;
+  const media = `/ppt/media/image${mediaIndex}.${metadata.extension}`;
+  s.changes.set(media, bytes);
+  const changedEdges = /* @__PURE__ */ new Set();
+  const relationNamespace = "http://schemas.openxmlformats.org/package/2006/relationships";
+  if (options.shared) {
+    for (const edge of s.index.inventory.relationships.filter(
+      (x) => x.targetPart && oldParts.has(x.targetPart)
+    )) {
+      const path = relPart(edge.owner), doc = s.doc(path);
+      const node = doc.root.children.find((x) => attr(x, "Id") === edge.id);
+      s.save(
+        path,
+        doc.merge(node, {
+          attributes: [
+            {
+              namespace: "",
+              localName: "Target",
+              value: relativePartReference(media, edge.owner.slice(0, edge.owner.lastIndexOf("/")))
+            }
+          ]
+        })
+      );
+      changedEdges.add(`${edge.owner}#${edge.id}`);
+    }
+  }
+  for (const occurrence of affected) {
+    context.signal?.throwIfAborted();
+    const owner = occurrence.sourcePart;
+    if (!options.shared) {
+      const path = relPart(owner), rels = s.doc(path), rid = nextRel(rels);
+      s.save(
+        path,
+        rels.spliceChildren(rels.root, rels.root.children.length, 0, [
+          `<Relationship xmlns="${relationNamespace}" Id="${rid}" Type="${s.r}/image" Target="${escape(relativePartReference(media, owner.slice(0, owner.lastIndexOf("/"))))}"/>`
+        ])
+      );
+      const doc = s.doc(owner), target = binding(doc, occurrence, s.r, s.a, s.p);
+      s.save(
+        owner,
+        doc.merge(target.node, {
+          attributes: [{ namespace: s.r, localName: target.attribute, value: rid }]
+        })
+      );
+      changedEdges.add(`${owner}#${occurrence.relationshipId}`);
+    }
+    if (options.preserveCrop === false) {
+      const doc = s.doc(owner), target = binding(doc, occurrence, s.r, s.a, s.p), crop = target.fill && child(target.fill, "srcRect", s.a);
+      if (crop)
+        s.save(owner, doc.spliceChildren(target.fill, target.fill.children.indexOf(crop), 1, []));
+    }
+    if (options.preserveGeometry === false) {
+      const doc = s.doc(owner), target = binding(doc, occurrence, s.r, s.a, s.p);
+      const properties = target.shape && child(target.shape, "spPr", s.p);
+      if (!properties)
+        throw new OfficeError(
+          "unsupported-edit",
+          "Geometry reset requires a shape transform.",
+          "validate-intent"
+        );
+      const transform = child(properties, "xfrm", s.a);
+      s.save(
+        owner,
+        doc.spliceChildren(
+          properties,
+          transform ? properties.children.indexOf(transform) : 0,
+          transform ? 1 : 0,
+          [
+            `<a:xfrm xmlns:a="${s.a}"><a:off x="0" y="0"/><a:ext cx="${width}" cy="${height}"/></a:xfrm>`
+          ]
+        )
+      );
+    }
+    if (options.preserveAltText === false || options.altText !== void 0) {
+      const doc = s.doc(owner), target = binding(doc, occurrence, s.r, s.a, s.p);
+      const identity = target.shape?.children.flatMap((x) => x.children).find((x) => x.name.namespace === s.p && x.name.localName === "cNvPr");
+      if (!identity)
+        throw new OfficeError(
+          "unsupported-edit",
+          "Alternative text requires a shape identity.",
+          "validate-intent"
+        );
+      s.save(
+        owner,
+        doc.merge(identity, {
+          attributes: [
+            { namespace: "", localName: "descr", value: options.altText ?? null },
+            ...options.preserveAltText === false ? [{ namespace: "", localName: "title", value: null }] : []
+          ]
+        })
+      );
+    }
+  }
+  const removedEdges = /* @__PURE__ */ new Set();
+  if (!options.shared)
+    for (const edge of s.index.inventory.relationships) {
+      const key = `${edge.owner}#${edge.id}`;
+      if (!changedEdges.has(key)) continue;
+      if (nodes(s.doc(edge.owner).root).some(
+        (node2) => node2.attributes.some((x) => x.name.namespace === s.r && x.value === edge.id)
+      ))
+        continue;
+      const path = relPart(edge.owner), doc = s.doc(path), node = doc.root.children.find((x) => attr(x, "Id") === edge.id);
+      s.save(path, doc.spliceChildren(doc.root, doc.root.children.indexOf(node), 1, []));
+      removedEdges.add(key);
+    }
+  for (const part of oldParts)
+    if (part && !s.index.inventory.relationships.some(
+      (edge) => edge.targetPart === part && !(options.shared ? changedEdges : removedEdges).has(`${edge.owner}#${edge.id}`)
+    ))
+      s.deleted.add(part);
+  let types = s.doc("/[Content_Types].xml");
+  const extensions = new Set(
+    [...s.deleted].map((part) => asciiKey(part.slice(part.lastIndexOf(".") + 1)))
+  );
+  for (let i = types.root.children.length - 1; i >= 0; i--) {
+    const node = types.root.children[i];
+    const deletedOverride = node.name.localName === "Override" && [...s.deleted].some(
+      (part) => asciiKey(part) === asciiKey(partName(attr(node, "PartName"), false))
+    );
+    const extension = attr(node, "Extension");
+    const unusedDefault = node.name.localName === "Default" && extension && extensions.has(asciiKey(extension)) && ![...s.reader.names, ...s.changes.keys()].some(
+      (name) => !s.deleted.has(name) && asciiKey(name.slice(name.lastIndexOf(".") + 1)) === asciiKey(extension)
+    );
+    if (deletedOverride || unusedDefault) types = types.spliceChildren(types.root, i, 1, []);
+  }
+  s.save(
+    "/[Content_Types].xml",
+    types.spliceChildren(types.root, types.root.children.length, 0, [
+      `<Override xmlns="${types.root.name.namespace}" PartName="${media}" ContentType="${escape(options.contentType)}"/>`
+    ])
+  );
+  const output = (await s.finish(media, affectedSlides)).bytes;
+  const ids = new Set(affected.map((x) => x.id));
+  const occurrences = (await readImages(output, { scope: "shared" }, context)).occurrences.filter(
+    (x) => ids.has(x.id)
+  );
+  context.signal?.throwIfAborted();
+  return { bytes: output, affected: occurrences.length, occurrences, affectedSlides };
+}
+
+export {
+  replaceImage
+};

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

@@ -0,0 +1,22 @@
+import {
+  normalizePropertyDate,
+  parseStoredDateTime
+} from "./chunk-VEUQWV2V.js";
+import {
+  InvalidValueError
+} from "./chunk-IQFRPIXH.js";
+
+// packages/safe-bash-docx-engine/src/review-resources.ts
+function reviewResourceDate(raw) {
+  if (raw === null) return null;
+  try {
+    return normalizePropertyDate(parseStoredDateTime(raw, "xsd").toISOString());
+  } catch (error) {
+    if (error instanceof InvalidValueError) return null;
+    throw error;
+  }
+}
+
+export {
+  reviewResourceDate
+};