@poe-platform/safe-bash 0.1.806 → 0.1.807

package/dist/safe-bash/command-chunks/chunk-3CHQG25N.js

@@ -0,0 +1,455 @@
+import {
+  writePackageArchive
+} from "./chunk-YRNBIU5U.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 {
+  partName
+} from "./chunk-XXFHTGV2.js";
+import {
+  OfficeError
+} from "./chunk-RR6QQ25D.js";
+
+// packages/safe-bash-presentation-engine/src/xml-view-validation.ts
+function reject() {
+  throw new OfficeError(
+    "unsupported-edit",
+    "Structured XML change exceeds the validated child-operation subset.",
+    "validate-intent"
+  );
+}
+function shell(document, element) {
+  const subtree = document.subtree(element);
+  const empty = subtree.spliceChildren(subtree.root, 0, subtree.root.children.length, []);
+  return empty.markup(empty.root, true);
+}
+function movable(element, presentation, drawing) {
+  const pending = [element];
+  while (pending.length) {
+    const node = pending.pop();
+    const extent = node.name.namespace === drawing && node.name.localName === "ext" && node.attributes.length === 2 && node.attributes.every(
+      (attribute) => !attribute.name.namespace && ["cx", "cy"].includes(attribute.name.localName)
+    );
+    if (![presentation, drawing].includes(node.name.namespace) || node.name.localName === "graphicData" || node.name.localName === "ext" && !extent)
+      return false;
+    if (node.attributes.some(
+      (attribute) => attribute.name.namespace && ![
+        "http://schemas.openxmlformats.org/officeDocument/2006/relationships",
+        "http://purl.oclc.org/ooxml/officeDocument/relationships",
+        "http://www.w3.org/XML/1998/namespace"
+      ].includes(attribute.name.namespace)
+    ))
+      return false;
+    pending.push(...node.children);
+  }
+  return true;
+}
+function validateXmlViewReplacement(reader, part, bytes, context, validate) {
+  try {
+    return validate(reader, part, bytes, context);
+  } catch (error) {
+    if (!(error instanceof OfficeError) || error.code !== "unsupported-edit") throw error;
+  }
+  validate(reader, part, reader.get(part), context);
+  const before = parseXmlPart(reader.get(part), context.validationLimits);
+  const after = parseXmlPart(bytes, context.validationLimits);
+  const presentation = before.root.name.namespace;
+  const drawing = presentation === "http://schemas.openxmlformats.org/presentationml/2006/main" ? "http://schemas.openxmlformats.org/drawingml/2006/main" : "http://purl.oclc.org/ooxml/drawingml/main";
+  const pending = [{ left: before.root, right: after.root }];
+  while (pending.length) {
+    const { left, right } = pending.pop();
+    if (before.markup(left, true) === after.markup(right, true)) continue;
+    if (left.name.namespace !== right.name.namespace || left.name.localName !== right.name.localName || shell(before, left) !== shell(after, right))
+      reject();
+    if (![presentation, drawing].includes(left.name.namespace) || ["graphicData", "ext"].includes(left.name.localName))
+      reject();
+    const structuralContainer = left.name.namespace === presentation && left.name.localName === "spTree" ? "drawing" : left.name.namespace === drawing && left.name.localName === "p" ? "paragraph" : null;
+    if (structuralContainer) {
+      const eligible = (node) => structuralContainer === "drawing" ? node.name.namespace === presentation && ["sp", "pic", "cxnSp", "grpSp"].includes(node.name.localName) : node.name.namespace === drawing && ["r", "br"].includes(node.name.localName);
+      const leftFixed = left.children.filter((child) => !eligible(child));
+      const rightFixed = right.children.filter((child) => !eligible(child));
+      if (leftFixed.length !== rightFixed.length) reject();
+      leftFixed.forEach((child, index) => {
+        if (before.markup(child, true) !== after.markup(rightFixed[index], true)) reject();
+      });
+      const candidates = left.children.map((child, index) => ({ child, index, markup: before.markup(child, true) })).filter((candidate2) => eligible(candidate2.child));
+      const moved = [];
+      let matched = true;
+      for (const [destination, child] of right.children.entries()) {
+        if (!eligible(child)) continue;
+        const index = candidates.findIndex(
+          (candidate3) => candidate3.markup === after.markup(child, true)
+        );
+        if (index < 0) {
+          matched = false;
+          break;
+        }
+        const [candidate2] = candidates.splice(index, 1);
+        if (candidate2.index !== destination) moved.push(candidate2.child);
+      }
+      if (!matched) {
+        if (left.children.length !== right.children.length || left.children.some(
+          (child, index) => child.name.namespace !== right.children[index].name.namespace || child.name.localName !== right.children[index].name.localName
+        ))
+          reject();
+        left.children.forEach(
+          (child, index) => pending.push({ left: child, right: right.children[index] })
+        );
+        continue;
+      }
+      for (const child of [...moved, ...candidates.map((candidate2) => candidate2.child)])
+        if (!movable(child, presentation, drawing)) reject();
+      if (structuralContainer === "drawing") {
+        if (right.children[0]?.name.localName !== "nvGrpSpPr" || right.children[1]?.name.localName !== "grpSpPr" || right.children.slice(2).some((child) => ["nvGrpSpPr", "grpSpPr"].includes(child.name.localName)))
+          reject();
+        const extension = right.children.findIndex((child) => child.name.localName === "extLst");
+        if (extension !== -1 && extension !== right.children.length - 1) reject();
+      } else {
+        for (const [index, child] of right.children.entries()) {
+          if (child.name.namespace !== drawing || !["pPr", "r", "br", "endParaRPr"].includes(child.name.localName))
+            reject();
+          if (child.name.localName === "pPr" && index !== 0 || child.name.localName === "endParaRPr" && index !== right.children.length - 1)
+            reject();
+        }
+      }
+      continue;
+    }
+    if (left.children.length !== right.children.length) reject();
+    left.children.forEach(
+      (child, index) => pending.push({ left: child, right: right.children[index] })
+    );
+  }
+  const candidate = {
+    ...reader,
+    get: (name) => name === part ? new Uint8Array(bytes) : reader.get(name)
+  };
+  return validate(candidate, part, bytes, context);
+}
+
+// packages/safe-bash-presentation-engine/src/xml-parts.ts
+import { SaxesParser } from "saxes";
+var namespaces = [
+  "http://schemas.openxmlformats.org/presentationml/2006/main",
+  "http://purl.oclc.org/ooxml/presentationml/main"
+];
+var relationshipNamespaces = [
+  "http://schemas.openxmlformats.org/officeDocument/2006/relationships",
+  "http://purl.oclc.org/ooxml/officeDocument/relationships"
+];
+var sequences = {
+  presentation: [
+    "sldMasterIdLst",
+    "notesMasterIdLst",
+    "handoutMasterIdLst",
+    "sldIdLst",
+    "sldSz",
+    "notesSz",
+    "smartTags",
+    "embeddedFontLst",
+    "custShowLst",
+    "photoAlbum",
+    "custDataLst",
+    "kinsoku",
+    "defaultTextStyle",
+    "modifyVerifier",
+    "extLst"
+  ],
+  sld: ["cSld", "clrMapOvr", "transition", "timing", "extLst"],
+  cSld: ["bg", "spTree", "custDataLst", "controls", "extLst"],
+  nvGrpSpPr: ["cNvPr", "cNvGrpSpPr", "nvPr"],
+  sp: ["nvSpPr", "spPr", "style", "txBody", "extLst"],
+  pic: ["nvPicPr", "blipFill", "spPr", "style", "extLst"],
+  graphicFrame: ["nvGraphicFramePr", "xfrm", "graphic", "extLst"]
+};
+function unsupported(message) {
+  throw new OfficeError("unsupported-edit", message, "validate-intent");
+}
+function select(reader, requested, context) {
+  const part = partName(requested, false);
+  if (part !== requested || !reader.names.includes(part))
+    throw new OfficeError(
+      "missing-selection",
+      "An exact existing package part is required.",
+      "select"
+    );
+  const contentType = part === "/[Content_Types].xml" ? "application/xml" : parseContentTypes(reader.get("/[Content_Types].xml"), context.validationLimits).get(part).split(";", 1)[0].trim().toLowerCase();
+  if (contentType !== "application/xml" && contentType !== "text/xml" && !contentType.endsWith("+xml"))
+    throw new OfficeError("unsupported-profile", "The selected part is not XML.", "select");
+  const bytes = reader.get(part);
+  return { part, bytes, contentType, document: parseXmlPart(bytes, context.validationLimits) };
+}
+function decode(bytes) {
+  const little = bytes[0] === 255 && bytes[1] === 254 || bytes[0] === 60 && bytes[1] === 0;
+  const big = bytes[0] === 254 && bytes[1] === 255 || bytes[0] === 0 && bytes[1] === 60;
+  return new TextDecoder(little ? "utf-16le" : big ? "utf-16be" : "utf-8", { fatal: true }).decode(
+    bytes
+  );
+}
+function namespaceDeclarations(document) {
+  const entries = [];
+  const parser = new SaxesParser({ xmlns: true });
+  parser.on("opentag", (tag) => entries.push(JSON.stringify(Object.entries(tag.ns).sort())));
+  parser.write(decode(document.bytes())).close();
+  return JSON.stringify(entries);
+}
+function pretty(document, maximum) {
+  const source = document.markup(document.root);
+  const stack = [];
+  let root;
+  let start = 0;
+  const parser = new SaxesParser({ xmlns: true });
+  parser.on("opentagstart", () => {
+    start = source.lastIndexOf("<", parser.position - 1);
+  });
+  parser.on("opentag", () => {
+    const node = {
+      start,
+      openEnd: parser.position,
+      closeStart: parser.position,
+      end: parser.position,
+      mixed: false,
+      children: []
+    };
+    if (stack.length) stack.at(-1).children.push(node);
+    else root = node;
+    stack.push(node);
+  });
+  parser.on("text", (text) => {
+    if (text.trim() && stack.length) stack.at(-1).mixed = true;
+  });
+  for (const event of ["comment", "cdata", "processinginstruction"])
+    parser.on(event, () => {
+      if (stack.length) stack.at(-1).mixed = true;
+    });
+  parser.on("closetag", () => {
+    const node = stack.pop();
+    node.end = parser.position;
+    node.closeStart = source.lastIndexOf("<", parser.position - 1);
+  });
+  parser.write(source).close();
+  const render = (node, depth) => {
+    if (node.mixed || !node.children.length) return source.slice(node.start, node.end);
+    const result = [
+      source.slice(node.start, node.openEnd),
+      ...node.children.map((child) => `
+${"  ".repeat(depth + 1)}${render(child, depth + 1)}`),
+      `
+${"  ".repeat(depth)}${source.slice(node.closeStart, node.end)}`
+    ].join("");
+    if (new TextEncoder().encode(result).length > maximum)
+      throw new OfficeError("resource-limit", "Pretty XML byte limit exceeded.", "serialize");
+    return result;
+  };
+  return render(root, 0);
+}
+async function getXmlPart(input, part, context, options = {}) {
+  if (Object.keys(options).some((key) => key !== "pretty") || options.pretty !== void 0 && typeof options.pretty !== "boolean")
+    throw new OfficeError("invalid-value", "Invalid XML display options.", "usage");
+  const selected = select(await readPackage(input, context), part, context);
+  return Object.freeze({
+    part: selected.part,
+    bytes: selected.bytes,
+    xml: options.pretty ? pretty(selected.document, context.validationLimits.maxBytes) : decode(selected.bytes),
+    format: options.pretty ? "pretty" : "original"
+  });
+}
+async function replaceXmlPart(input, part, replacement, context) {
+  const source = await readBinary(input, context);
+  const reader = await readPackage(source, context);
+  const bytes = await readBinary(replacement, context, {
+    maxBytes: context.validationLimits.maxBytes
+  });
+  const candidate = validateXmlViewReplacement(
+    reader,
+    part,
+    bytes,
+    context,
+    validateXmlPartReplacement
+  );
+  const original = reader.get(part);
+  if (bytes.length === original.length && bytes.every((byte, index) => byte === original[index]))
+    return source;
+  return writePackageArchive(
+    reader.names.map((name) => ({ name: name.slice(1), bytes: candidate.get(name) })),
+    context,
+    { compression: "auto", source }
+  );
+}
+function validateXmlPartReplacement(reader, part, bytes, context) {
+  const selected = select(reader, part, context);
+  const graph = readRelationshipGraph(reader, context.validationLimits);
+  const contentTypes = parseContentTypes(
+    reader.get("/[Content_Types].xml"),
+    context.validationLimits
+  );
+  let nodes = 0;
+  let total = 0;
+  for (const name of reader.names) {
+    context.signal?.throwIfAborted();
+    if (name === "/[Content_Types].xml") continue;
+    const type = contentTypes.get(name).split(";", 1)[0].trim().toLowerCase();
+    if (type.includes("digital-signature") || type.includes("macroenabled") || type.includes("vbaproject") || name.toLowerCase().startsWith("/_xmlsignatures/"))
+      unsupported("Signed and macro-enabled packages cannot be changed.");
+    if (type.endsWith("+xml") || type === "application/xml" || type === "text/xml") {
+      const data = reader.get(name);
+      total += data.length;
+      if (total > context.validationLimits.maxBytes || nodes >= context.validationLimits.maxNodes)
+        throw new OfficeError("resource-limit", "Package XML inspection limit exceeded.", "index");
+      const document = parseXmlPart(data, {
+        ...context.validationLimits,
+        maxNodes: context.validationLimits.maxNodes - nodes
+      });
+      nodes += document.nodeCount;
+      const pending2 = [document.root];
+      while (pending2.length) {
+        const node = pending2.pop();
+        for (const attribute of node.attributes)
+          if (relationshipNamespaces.includes(attribute.name.namespace) && !graph.outgoing(name).some((edge) => edge.id === attribute.value))
+            throw new OfficeError(
+              "invalid-opc",
+              "XML references an absent relationship.",
+              "validate-intent"
+            );
+        if (namespaces.includes(node.name.namespace) && node.name.localName === "modifyVerifier")
+          unsupported("Protected presentations cannot be changed.");
+        pending2.push(...node.children);
+      }
+    }
+  }
+  for (const owner of ["/", ...graph.parts])
+    if (graph.outgoing(owner).some(
+      (edge) => edge.type.includes("/digital-signature/") || edge.type.endsWith("/vbaProject")
+    ))
+      unsupported("Signed and macro-enabled packages cannot be changed.");
+  const root = selected.document.root;
+  const expected = (/* @__PURE__ */ new Map([
+    [
+      "application/vnd.openxmlformats-officedocument.presentationml.presentation.main+xml",
+      "presentation"
+    ],
+    [
+      "application/vnd.openxmlformats-officedocument.presentationml.template.main+xml",
+      "presentation"
+    ],
+    [
+      "application/vnd.openxmlformats-officedocument.presentationml.slideshow.main+xml",
+      "presentation"
+    ],
+    ["application/vnd.openxmlformats-officedocument.presentationml.slide+xml", "sld"]
+  ])).get(selected.contentType);
+  if (!expected)
+    unsupported(
+      "Replacement supports presentation and slide XML with unchanged element structure."
+    );
+  const changed = parseXmlPart(bytes, context.validationLimits);
+  for (const size of changed.root.children.filter(
+    (node) => node.name.namespace === changed.root.name.namespace && node.name.localName === "sldSz"
+  )) {
+    for (const axis of ["cx", "cy"]) {
+      const value = size.attributes.find(
+        (attribute) => !attribute.name.namespace && attribute.name.localName === axis
+      )?.value;
+      const number = Number(value);
+      if (!value || [...value].some((character) => character < "0" || character > "9") || !Number.isSafeInteger(number) || number < 914400 || number > 51206400)
+        throw new OfficeError(
+          "invalid-opc",
+          "Invalid authored slide dimensions.",
+          "validate-result"
+        );
+    }
+  }
+  if (changed.root.name.localName !== expected || root.name.localName !== expected)
+    throw new OfficeError(
+      "invalid-opc",
+      "XML root does not match the content type.",
+      "validate-result"
+    );
+  if (!namespaces.includes(root.name.namespace) || root.name.namespace !== changed.root.name.namespace)
+    unsupported("XML replacement must preserve the presentation dialect.");
+  if (namespaceDeclarations(selected.document) !== namespaceDeclarations(changed))
+    unsupported("XML replacement must preserve namespace declarations.");
+  const pending = [{ before: root, after: changed.root }];
+  const understood = [
+    root.name.namespace,
+    namespaces.indexOf(root.name.namespace) === 0 ? "http://schemas.openxmlformats.org/drawingml/2006/main" : "http://purl.oclc.org/ooxml/drawingml/main"
+  ];
+  const edges = graph.outgoing(part);
+  while (pending.length) {
+    const { before, after } = pending.pop();
+    if (before.name.namespace !== after.name.namespace || before.name.localName !== after.name.localName || before.children.length !== after.children.length)
+      unsupported("XML replacement must preserve element names and sequence.");
+    if (!understood.includes(after.name.namespace) || ["graphicData", "ext"].includes(after.name.localName)) {
+      if (selected.document.markup(before) !== changed.markup(after))
+        unsupported("Opaque XML content must remain unchanged.");
+      continue;
+    }
+    for (const attribute of [...before.attributes, ...after.attributes]) {
+      if (!attribute.name.namespace) continue;
+      const matches = (item) => item.name.namespace === attribute.name.namespace && item.name.localName === attribute.name.localName;
+      const left = before.attributes.find(matches);
+      const right = after.attributes.find(matches);
+      if (right && relationshipNamespaces.includes(attribute.name.namespace) && !edges.some((edge) => edge.id === right.value))
+        throw new OfficeError(
+          "invalid-opc",
+          "XML references an absent relationship.",
+          "validate-result"
+        );
+      if (left?.value !== right?.value)
+        unsupported("Namespaced XML attributes must remain unchanged.");
+    }
+    if (namespaces.includes(after.name.namespace) && after.name.localName === "modifyVerifier")
+      unsupported("Protection changes are unsupported.");
+    const order = after.name.namespace === root.name.namespace ? sequences[after.name.localName] : void 0;
+    if (order) {
+      let previous = -1;
+      for (const child of after.children) {
+        const rank = order.indexOf(child.name.localName);
+        if (rank < 0 || rank <= previous) unsupported("Unsupported XML child sequence.");
+        previous = rank;
+      }
+    }
+    for (const attribute of after.attributes) {
+      if (relationshipNamespaces.includes(attribute.name.namespace) && attribute.name.namespace !== relationshipNamespaces[namespaces.indexOf(root.name.namespace)])
+        unsupported("XML replacement must preserve relationship dialect.");
+    }
+    after.children.forEach(
+      (child, index) => pending.push({ before: before.children[index], after: child })
+    );
+  }
+  const candidate = {
+    names: reader.names,
+    has: reader.has,
+    get: (name) => name === part ? new Uint8Array(bytes) : reader.get(name),
+    relsXmlFor: reader.relsXmlFor
+  };
+  if (!validatePresentation(candidate, context.validationLimits).valid)
+    throw new OfficeError(
+      "invalid-opc",
+      "Replacement fails presentation graph validation.",
+      "validate-result"
+    );
+  return candidate;
+}
+
+export {
+  validateXmlViewReplacement,
+  getXmlPart,
+  replaceXmlPart,
+  validateXmlPartReplacement
+};

package/dist/safe-bash/command-chunks/chunk-3JQ3RF2O.js

@@ -0,0 +1,72 @@
+import {
+  documentTypes
+} from "./chunk-GLPIFP7N.js";
+import {
+  trimXmlWhitespace
+} from "./chunk-VEUQWV2V.js";
+import {
+  parseMediaType
+} from "./chunk-MWAAMNAM.js";
+
+// packages/safe-bash-docx-engine/src/comment-id.ts
+function storedCommentId(value) {
+  if (value === void 0) return null;
+  const raw = trimXmlWhitespace(value), digits = raw[0] === "+" || raw[0] === "-" ? raw.slice(1) : raw;
+  if (!digits || [...digits].some((char) => !"0123456789".includes(char))) return null;
+  const id = Number(raw);
+  return Number.isSafeInteger(id) && id >= 0 ? id === 0 ? 0 : id : null;
+}
+function nextCommentId(ids, budget) {
+  budget.charge("work", ids.length + 1);
+  let largest = -1;
+  for (const id of ids) largest = Math.max(largest, id);
+  if (largest < 2147483647) return largest + 1;
+  budget.charge("retainedBytes", ids.length * 16);
+  const used = new Set(ids);
+  let next = 0;
+  while (used.has(next)) {
+    budget.charge("work", 1);
+    next++;
+  }
+  return next;
+}
+
+// packages/safe-bash-docx-engine/src/comment-stories.ts
+function commentStoryParts(graph, main, comments, word, relationships, root, budget) {
+  const roles = ["header", "footer", "footnotes", "endnotes", "comments", "glossaryDocument"];
+  const contentType = (role) => `application/vnd.openxmlformats-officedocument.wordprocessingml.${role === "glossaryDocument" ? "document.glossary" : role}+xml`;
+  const rootName = (role) => role === "header" ? "hdr" : role === "footer" ? "ftr" : role;
+  const nativeRoots = new Map([
+    ...Object.values(documentTypes).map((type) => [type, "document"]),
+    ...roles.map((role) => [contentType(role), rootName(role)])
+  ]);
+  const parts = /* @__PURE__ */ new Set();
+  for (const owner of graph.parts) {
+    budget.charge("work", 1);
+    const expected = nativeRoots.get(parseMediaType(owner.content_type));
+    if (expected === void 0) continue;
+    const xml = root(owner.partname);
+    if (xml.namespace !== word || xml.localName !== expected) continue;
+    const edges = graph.relationships(owner.partname);
+    if (owner.partname !== main && (comments === void 0 || !edges.some((edge) => !edge.is_external && edge.reltype === relationships + "/comments" && edge.target_part.partname === comments))) continue;
+    budget.charge("retainedBytes", 24);
+    parts.add(owner.partname);
+    for (const edge of edges) {
+      budget.charge("work", 1);
+      if (edge.is_external) continue;
+      const role = roles.find((role2) => edge.reltype === relationships + "/" + role2);
+      if (role === void 0 || parseMediaType(edge.target_part.content_type) !== contentType(role)) continue;
+      const target = root(edge.target_part.partname);
+      if (target.namespace !== word || target.localName !== rootName(role)) continue;
+      budget.charge("retainedBytes", 24);
+      parts.add(edge.target_part.partname);
+    }
+  }
+  return parts;
+}
+
+export {
+  storedCommentId,
+  nextCommentId,
+  commentStoryParts
+};

package/dist/safe-bash/command-chunks/chunk-3MLJWSYL.js

@@ -0,0 +1,92 @@
+import {
+  Presentation
+} from "./chunk-AEJZEGW7.js";
+import {
+  SlidePlaceholder
+} from "./chunk-EUXUCRCI.js";
+import {
+  chartTypes,
+  validateChartData
+} from "./chunk-F2ORFLCH.js";
+import {
+  admitImage
+} from "./chunk-45BW6MGM.js";
+import {
+  readSelectionIndex
+} from "./chunk-CKEODJVT.js";
+import {
+  readBinary
+} from "./chunk-TL3KDYEM.js";
+import {
+  ValueError
+} from "./chunk-RR6QQ25D.js";
+
+// packages/safe-bash-presentation-engine/src/command-placeholder.ts
+async function insertPlaceholder(input, options, context) {
+  const data = (value, keys) => {
+    if (!value || typeof value !== "object" || ![Object.prototype, null].includes(Object.getPrototypeOf(value)) || Reflect.ownKeys(value).some(
+      (key) => typeof key !== "string" || !keys.includes(key) || !("value" in Object.getOwnPropertyDescriptor(value, key))
+    ))
+      throw new ValueError("Placeholder options require closed stored data.");
+  };
+  data(options, ["slide", "placeholder", "content"]);
+  data(options.content, [
+    "kind",
+    "input",
+    "altText",
+    "contentType",
+    "rows",
+    "columns",
+    "type",
+    "data"
+  ]);
+  const content = options.content;
+  if (!["picture", "table", "chart"].includes(content.kind))
+    throw new ValueError("Unknown placeholder content kind.");
+  data(
+    content,
+    content.kind === "picture" ? ["kind", "input", "altText", "contentType"] : content.kind === "table" ? ["kind", "rows", "columns"] : ["kind", "type", "data"]
+  );
+  if (content.kind === "table" && (!Number.isSafeInteger(content.rows) || !Number.isSafeInteger(content.columns) || content.rows < 1 || content.columns < 1 || content.rows * content.columns > 25e4))
+    throw new ValueError("Invalid placeholder table dimensions.");
+  if (content.kind === "chart") {
+    if (!chartTypes.includes(content.type)) throw new ValueError("Unknown placeholder chart type.");
+    validateChartData(content.data, content.type);
+  }
+  if (content.kind === "picture" && (content.altText !== void 0 && typeof content.altText !== "string" || content.contentType !== void 0 && !["image/png", "image/jpeg"].includes(content.contentType)))
+    throw new ValueError("Invalid picture placeholder metadata.");
+  if (!Number.isSafeInteger(options.slide) || options.slide < 1 || !Number.isSafeInteger(options.placeholder) || options.placeholder < 0 || options.placeholder > 4294967295)
+    throw new ValueError("Placeholder insertion requires a slide and nonnegative idx.");
+  const pictureBytes = content.kind === "picture" ? await readBinary(content.input, context, { maxBytes: context.archiveLimits.maxEntryBytes }) : void 0;
+  if (content.kind === "picture" && content.contentType !== void 0)
+    admitImage(pictureBytes, content.contentType);
+  const deck = await Presentation(input, context);
+  const target = deck.slides.get(options.slide - 1).placeholders.get(options.placeholder);
+  if (!(target instanceof SlidePlaceholder))
+    throw new ValueError("Placeholder is already populated.");
+  const id = target.shape_id;
+  if (content.kind === "table") target.insert_table(content.rows, content.columns);
+  else if (content.kind === "chart") await target.insert_chart(content.type, content.data);
+  else {
+    const picture = await target.insert_picture(pictureBytes);
+    if (content.altText !== void 0) picture.description = content.altText;
+  }
+  const bytes = await deck.save();
+  const index = await readSelectionIndex(bytes, context);
+  const slide = index.inventory.slides[options.slide - 1];
+  const records = index.objects.filter(
+    (record) => record.part === slide.part && record.id === String(id)
+  );
+  return {
+    bytes,
+    part: slide.part,
+    affected: 1,
+    affectedSlides: [options.slide],
+    records,
+    shapeId: id
+  };
+}
+
+export {
+  insertPlaceholder
+};

package/dist/safe-bash/command-chunks/{chunk-ASYR2LU7.js → chunk-3RQCLLQA.js}

@@ -33,7 +33,7 @@ import {
   p
 } from "./chunk-QIFS4QHZ.js";
 
-// packages/safe-bash-command-pandoc/dist/chunks/chunk-FRVGRM5K.js
+// packages/safe-bash-command-pandoc/dist/chunks/chunk-GOVFLFWZ.js
 import { builtInDirectContextExecutors as ku, syncCommandEvaluators as Eu } from "../../safe-bash-contracts/runtime-control.js";
 import * as mb from "../../safe-bash-markdown-engine/gfm-syntax.js";
 import * as gb from "../../safe-bash-markdown-engine/commonmark-blocks.js";
@@ -10078,7 +10078,7 @@ async function Mf(i10, e2) {
   let l = 65536 + Math.ceil(s / 8) * Math.ceil(r / 8) * 64 * 64;
   e2.charge("retainedBytes", l), e2.charge("expandedBytes", l), e2.checkpoint(s * r);
   try {
-    let { decodeJpegImage: c2 } = await import("./index.browser-2NLML6H4.js"), f = c2(i10);
+    let { decodeJpegImage: c2 } = await import("../../image-ast/index.js"), f = c2(i10);
     (f.width !== s || f.height !== r || f.data.length !== s * r * 4) && ue(e2, "JPEG decoded dimensions mismatch");
   } catch (c2) {
     if (c2 instanceof t) throw c2;
@@ -11487,11 +11487,11 @@ var rc = { format: "odt", imageResources: "embed", async write(i10, e2) {
 var oc = { name: "odt", reader: sc, writer: rc, read: true, write: true, media: "binary", inputEncoding: "bytes", suffixes: ["odt"], extensions: {}, options: { read: [], write: ["standalone"] }, inputBudget: "compressedBytes" };
 var ac = { name: "pptx", read: true, write: true, media: "binary", inputEncoding: "bytes", reader: { format: "pptx", async read(i10, e2, t2) {
   e2.signal?.throwIfAborted();
-  let { pptxReader: n } = await import("./pptx-XG3YSXWZ-XAG36NAB.js");
+  let { pptxReader: n } = await import("./pptx-YDKHIGCD-H7FU4VMJ.js");
   return e2.signal?.throwIfAborted(), n.read(i10, e2, t2);
 } }, writer: { format: "pptx", imageResources: "embed", async write(i10, e2, t2) {
   e2.signal?.throwIfAborted();
-  let { pptxWriter: n } = await import("./pptx-XG3YSXWZ-XAG36NAB.js");
+  let { pptxWriter: n } = await import("./pptx-YDKHIGCD-H7FU4VMJ.js");
   return e2.signal?.throwIfAborted(), n.write(i10, e2, t2);
 } }, suffixes: ["pptx"], extensions: {}, options: { read: [], write: ["standalone"] } };
 var yn = ["", [], []];
@@ -11500,7 +11500,7 @@ var lc = { format: "xlsx", async read(i10, e2) {
   }, environment: { env: {}, locale: "C", timezone: "UTC" }, limits: { inputBytes: t2.inputBytes, outputBytes: t2.outputBytes, cells: t2.tableCells, sheets: t2.parts, operations: t2.work, compressedBytes: t2.compressedBytes, inflatedBytes: Math.min(t2.expandedBytes, t2.retainedBytes), zipEntries: t2.parts, xmlDepth: t2.xmlDepth, workbookNodes: t2.xmlNodes, workbookTextBytes: t2.text, workbookWork: t2.work } };
   try {
     if (i10.bytes.length < 22) throw new t("E_PARSE", "read", "Truncated XLSX archive", "xlsx");
-    let { readXlsx: s, recalculateWorkbook: r } = await import("../../safe-bash-command-ssconvert/index.js");
+    let { readXlsx: s } = await import("../../spreadsheet-format-xlsx/xlsx.js"), { recalculateWorkbook: r } = await import("../../spreadsheet-engine/formulas/recalculation.js");
     e2.checkpoint();
     let o2 = await r(await s(i10.bytes, n), n, { force: false, ignoreCalculationMode: true }), a = [], l = 0;
     for (let c2 of o2.sheets) {