@poe-platform/safe-bash 0.1.810 → 0.1.812

package/dist/safe-bash/command-chunks/{chunk-3ZWBBS6U.js → chunk-NARD63DY.js}

@@ -1,35 +1,425 @@
+import {
+  openPackageArchive
+} from "./chunk-ZXR6LXV5.js";
+import {
+  openRetainedPresentationIndex,
+  stageRetainedOutput,
+  streamJson
+} from "./chunk-L5MCW6CM.js";
 import {
   writePackageArchive
-} from "./chunk-VPDSQPSN.js";
+} from "./chunk-DM2CPMB4.js";
 import {
   SelectionError,
   readSelectionIndex
-} from "./chunk-S4IIOSRA.js";
+} from "./chunk-X7FA7ZD5.js";
 import {
   readPackage
-} from "./chunk-SFCERNHU.js";
+} from "./chunk-XPD636C4.js";
 import {
   readBinary
-} from "./chunk-KMMAJ6H6.js";
+} from "./chunk-PNGDJA6M.js";
 import {
+  openRetainedPresentationValidation,
   validatePresentation
-} from "./chunk-MMBRBANA.js";
+} from "./chunk-RNSKXOG3.js";
+import {
+  openRetainedContentTypes,
+  openRetainedRelationshipGraph
+} from "./chunk-QC5RMGSA.js";
 import {
   parseXmlPart
-} from "./chunk-5L6GHFRW.js";
+} from "./chunk-554Z6IKP.js";
 import {
   parseContentTypes
-} from "./chunk-DVQBZXMQ.js";
+} from "./chunk-WJCN2IXI.js";
 import {
   readRelationshipGraph
-} from "./chunk-NTRZMQZP.js";
+} from "./chunk-ZMHEGDU2.js";
 import {
   asciiKey,
+  partName,
   relativePartReference
-} from "./chunk-AXWPJRY6.js";
+} from "./chunk-36XGIPOG.js";
 import {
-  OfficeError
-} from "./chunk-KJ3PEDI2.js";
+  OfficeError,
+  RetainedValues,
+  characters,
+  equal,
+  literal,
+  openRetainedXmlDocument,
+  resolveOfficeResources,
+  stageRetainedXmlEdits
+} from "./chunk-Q73EMLLZ.js";
+
+// packages/safe-bash-presentation-engine/src/retained-slide-settings.ts
+import { PagedStorage } from "@poe-platform/safe-fs/storage";
+function unsupported(message) {
+  throw new OfficeError("unsupported-edit", message, "validate-intent");
+}
+async function contains(source, needles, lower = false) {
+  const maximum = Math.max(...needles.map((value) => value.length));
+  let window = "";
+  for await (const character of characters(source)) {
+    window = (window + (lower ? character.toLowerCase() : character)).slice(-maximum);
+    if (needles.some((value) => window.endsWith(value))) return true;
+  }
+  return false;
+}
+async function* escaped(text, quote) {
+  let buffer = "";
+  for (const character of text) {
+    buffer += character === "&" ? "&amp;" : character === "<" ? "&lt;" : character === ">" ? "&gt;" : character === quote ? quote === '"' ? "&quot;" : "&apos;" : character === "	" ? "&#9;" : character === "\n" ? "&#10;" : character === "\r" ? "&#13;" : character;
+    if (buffer.length >= 4096) {
+      yield* literal(buffer);
+      buffer = "";
+    }
+  }
+  if (buffer) yield* literal(buffer);
+}
+async function openRetainedSlideSettings(archive, fingerprint, options, settings) {
+  const context = resolveOfficeResources(settings), workingStorage = { ...settings.workingStorage }, signal = context.signal ?? new AbortController().signal, resources = { ...context, workingStorage, signal };
+  const prepared = prepareSlideMutationOptions(options, context);
+  if ("position" in options) throw new OfficeError("invalid-value", "Slide settings do not reorder slides.", "usage");
+  const queries = prepared.map((query) => ({ ...query, ...query.position ? { position: { ...query.position } } : {} }));
+  const name = options.name, hidden = options.hidden, allowEmpty = options.allowEmpty;
+  const limits = { ...context.xmlLimits, ...context.relationshipLimits, maxBytes: Math.min(context.xmlLimits.maxBytes, context.relationshipLimits.maxBytes), maxEntries: context.archiveLimits.maxMembers };
+  if (!workingStorage.fs || !workingStorage.directory?.startsWith("/") || workingStorage.cacheBytes !== void 0 && (!Number.isSafeInteger(workingStorage.cacheBytes) || workingStorage.cacheBytes < 16384 || workingStorage.cacheBytes % 16384)) throw new OfficeError("invalid-value", "Explicit slide mutation storage and a valid cache budget are required.", "usage");
+  const pages = new PagedStorage({ fs: workingStorage.fs, cwd: workingStorage.directory, env: {}, signal }, (workingStorage.cacheBytes ?? 1024 * 1024) / 16384);
+  let closed = false, closing, first = 0, last = 0, affected = 0, changed = false;
+  let types, graph, index;
+  const check = () => {
+    if (closed) throw new OfficeError("invalid-handle", "Slide mutation is closed.", "serialize");
+    if (signal.aborted) throw new OfficeError("cancelled", "Operation cancelled.", "serialize");
+  };
+  const close = () => {
+    closed = true;
+    return closing ??= (async () => {
+      const results = await Promise.allSettled([types?.close(), graph?.close(), index?.close(), pages.close()]);
+      for (const result of results) if (result.status === "rejected") throw result.reason;
+    })();
+  };
+  const values = new RetainedValues(pages, check, signal);
+  async function write(pointer, row2) {
+    const bytes = new Uint8Array(row2.length * 8), view = new DataView(bytes.buffer);
+    row2.forEach((value, i) => view.setFloat64(i * 8, value, true));
+    await pages.write(pointer, bytes);
+  }
+  async function row(pointer, count) {
+    const bytes = await pages.read(pointer, count * 8), view = new DataView(bytes.buffer, bytes.byteOffset, bytes.byteLength);
+    return Array.from({ length: count }, (_, i) => view.getFloat64(i * 8, true));
+  }
+  async function* entries() {
+    check();
+    for (let pointer = first; pointer; ) {
+      const item = await row(pointer, 3);
+      let text = "";
+      const decoder = new TextDecoder();
+      for await (const bytes of values.read({ start: item[1], length: item[2] })) text += decoder.decode(bytes, { stream: true });
+      yield JSON.parse(text + decoder.decode());
+      pointer = item[0];
+      check();
+    }
+  }
+  async function replacement(part) {
+    check();
+    const value = await values.find("changes", () => literal(asciiKey(partName(part, false))));
+    return value ? values.read(value) : void 0;
+  }
+  const candidate = {
+    async *parts() {
+      check();
+      for await (const part of archive.parts()) {
+        check();
+        yield part;
+      }
+    },
+    async has(part) {
+      check();
+      return archive.has(part);
+    },
+    async byteLength(part) {
+      check();
+      return (await values.find("changes", () => literal(asciiKey(partName(part, false)))))?.length ?? archive.byteLength(part);
+    },
+    async *read(part) {
+      check();
+      const value = await replacement(part);
+      if (value) yield* value;
+      else yield* archive.read(part);
+      check();
+    }
+  };
+  try {
+    types = await openRetainedContentTypes(archive.read("/[Content_Types].xml"), resources, limits);
+    graph = await openRetainedRelationshipGraph(archive, { ...resources, xmlLimits: { ...context.xmlLimits, maxBytes: context.relationshipLimits.maxBytes } });
+    for await (const part of archive.parts()) if (part !== "/[Content_Types].xml" && (part.toLowerCase().startsWith("/_xmlsignatures/") || await contains(await types.get(part), ["digital-signature", "macroenabled", "vbaproject"], true))) unsupported("Signed and macro-enabled packages cannot be changed.");
+    async function* owners() {
+      yield "/";
+      yield* graph.parts();
+    }
+    for await (const owner of owners()) for await (const edge of graph.outgoing(owner)) {
+      if (await contains(edge.type(), ["/digital-signature/"])) unsupported("Signed and macro-enabled packages cannot be changed.");
+      let suffix = "";
+      for await (const character of characters(edge.type())) suffix = (suffix + character).slice(-11);
+      if (suffix === "/vbaProject") unsupported("Signed and macro-enabled packages cannot be changed.");
+    }
+    await types.close();
+    types = void 0;
+    await graph.close();
+    graph = void 0;
+    const validation = await openRetainedPresentationValidation(archive, resources, limits);
+    const valid = validation.valid;
+    await validation.close();
+    if (!valid) throw new OfficeError("invalid-opc", "Slide editing requires a valid presentation graph.", "validate-intent");
+    index = await openRetainedPresentationIndex(archive, fingerprint, resources);
+    for (const query of queries) {
+      try {
+        for await (const record of index.records.select(query)) {
+          if (record.kind !== "slide" || await values.find("selected", () => literal(record.id))) throw new SelectionError("invalid-selection");
+          const id = await values.store(literal(record.id));
+          await values.insert("selected", id, id);
+          const target = await values.store(literal(JSON.stringify({ location: record.location, part: record.part }))), pointer = pages.allocate(24);
+          await write(pointer, [0, target.start, target.length]);
+          if (last) await write(last, [pointer]);
+          else first = pointer;
+          last = pointer;
+          affected++;
+        }
+      } catch (error) {
+        if (!(allowEmpty && error instanceof SelectionError && error.code === "missing-selection")) throw error;
+      }
+    }
+    const presentation = await openRetainedXmlDocument(archive.read(index.records.main), resources);
+    let failed = false;
+    try {
+      let stack = pages.allocate(16);
+      await write(stack, [0, presentation.reference(presentation.root)]);
+      while (stack) {
+        const frame = await row(stack, 2);
+        stack = frame[0];
+        const node = await presentation.node(frame[1]);
+        if (node.kind !== "element") continue;
+        if (await equal(presentation.namespace(node), literal("http://schemas.openxmlformats.org/markup-compatibility/2006"))) unsupported("Conditional presentation structure cannot be changed.");
+        if (await equal(presentation.raw(node.localName), literal("modifyVerifier")) && await equal(presentation.namespace(node), presentation.namespace(presentation.root))) unsupported("Protected presentations cannot be changed.");
+        for await (const child2 of presentation.children(node)) {
+          const pointer = pages.allocate(16);
+          await write(pointer, [stack, presentation.reference(child2)]);
+          stack = pointer;
+        }
+      }
+    } catch (error) {
+      failed = true;
+      throw error;
+    } finally {
+      try {
+        await presentation.close();
+      } catch (error) {
+        if (!failed) await Promise.reject(error);
+      }
+    }
+    for await (const target of entries()) {
+      const document = await openRetainedXmlDocument(archive.read(target.part), resources);
+      let failed2 = false;
+      try {
+        const changes = [];
+        async function attr2(node, key) {
+          for await (const value of document.attributes(node)) if (await equal(document.namespace(value), literal("")) && await equal(document.raw(value.localName), literal(key))) return value;
+          return void 0;
+        }
+        if (name !== void 0) {
+          let common;
+          for await (const child2 of document.children(document.root)) if (child2.kind === "element" && await equal(document.namespace(child2), document.namespace(document.root)) && await equal(document.raw(child2.localName), literal("cSld"))) {
+            if (common) throw new OfficeError("ambiguous-selection", "Ambiguous presentation structure.", "select");
+            common = child2;
+          }
+          if (!common) unsupported("Conditional slide labels cannot be changed.");
+          const value = await attr2(common, "name");
+          if (!await equal(value ? document.text(value) : literal(""), literal(name))) changes.push({ node: common.name.start, attribute: "name", value: name || null, existing: Boolean(value) });
+        }
+        if (hidden !== void 0) {
+          const value = await attr2(document.root, "show");
+          let show = "", started = false, trailing = false;
+          if (value) for await (const character of characters(document.text(value))) {
+            if (!character.trim()) {
+              if (started) trailing = true;
+            } else {
+              if (trailing || show.length >= 5) throw new OfficeError("invalid-opc", "Invalid slide visibility.", "validate-intent");
+              started = true;
+              show += character;
+            }
+          }
+          if (value && !["0", "1", "true", "false"].includes(show)) throw new OfficeError("invalid-opc", "Invalid slide visibility.", "validate-intent");
+          if ((show === "0" || show === "false") !== hidden) changes.push({ node: document.root.name.start, attribute: "show", value: hidden ? "0" : "1", existing: Boolean(value) });
+        }
+        if (changes.length) {
+          const mutation = await stageRetainedXmlEdits(archive.read(target.part), async function* (xml) {
+            let active, attributeStart = 0, matching = false;
+            for await (const token of xml.tokens()) {
+              if (token.kind === "start-name") {
+                active = changes.find((change) => change.node === token.range.start);
+                matching = false;
+              } else if (active && token.kind === "attribute-name") {
+                attributeStart = token.range.start;
+                matching = await equal(xml.read(token.range), literal(active.attribute));
+              } else if (active && token.kind === "attribute-value") {
+                if (matching) {
+                  if (active.value === null) yield { range: { start: attributeStart, length: token.range.start + token.range.length + 1 - attributeStart }, replacement: literal("") };
+                  else {
+                    let quote = '"';
+                    for await (const bytes of xml.read({ start: token.range.start - 1, length: 1 })) quote = String.fromCharCode(bytes[0]);
+                    yield { range: token.range, replacement: escaped(active.value, quote) };
+                  }
+                }
+              } else if (active && token.kind === "start-end") {
+                if (!active.existing && active.value !== null) {
+                  const change = active;
+                  yield { range: { start: token.range.start - (token.empty ? 2 : 1), length: 0 }, replacement: (async function* () {
+                    yield* literal(` ${change.attribute}="`);
+                    yield* escaped(change.value, '"');
+                    yield* literal('"');
+                  })() };
+                }
+                active = void 0;
+              }
+            }
+          }, resources);
+          let mutationFailed = false;
+          try {
+            const value = await values.store(mutation.bytes()), key = await values.store(literal(asciiKey(target.part)));
+            await values.insert("changes", key, value);
+            changed = true;
+          } catch (error) {
+            mutationFailed = true;
+            throw error;
+          } finally {
+            try {
+              await mutation.close();
+            } catch (error) {
+              if (!mutationFailed) await Promise.reject(error);
+            }
+          }
+        }
+      } catch (error) {
+        failed2 = true;
+        throw error;
+      } finally {
+        try {
+          await document.close();
+        } catch (error) {
+          if (!failed2) await Promise.reject(error);
+        }
+      }
+    }
+    if (changed) {
+      const result = await openRetainedPresentationValidation(candidate, resources, limits);
+      const valid2 = result.valid;
+      await result.close();
+      if (!valid2) throw new OfficeError("invalid-opc", "Changed slides fail graph validation.", "validate-result");
+    }
+    await index.close();
+    index = void 0;
+    check();
+    return Object.freeze({ ...candidate, changed, affected, replacement, async *targets() {
+      for await (const entry of entries()) yield entry.location;
+    }, close });
+  } catch (error) {
+    await close().catch(() => {
+    });
+    throw error;
+  }
+}
+
+// packages/safe-bash-presentation-engine/src/retained-slide-publication.ts
+import { PagedStorage as PagedStorage2 } from "@poe-platform/safe-fs/storage";
+import { sha256 } from "@noble/hashes/sha2.js";
+async function stageRetainedSlideSettings(input, options, settings, output) {
+  const signal = settings.signal ?? new AbortController().signal;
+  const hash = sha256.create();
+  for await (const bytes of input.stream()) {
+    signal.throwIfAborted();
+    hash.update(bytes);
+  }
+  const hex = (bytes) => Array.from(bytes, (byte) => byte.toString(16).padStart(2, "0")).join("");
+  const before = hex(hash.digest());
+  const archive = await openPackageArchive(input, settings);
+  let mutation, pages, response;
+  let closed = false, closing;
+  const check = () => {
+    if (closed) throw new OfficeError("invalid-handle", "Slide output is closed.", "publish");
+    signal.throwIfAborted();
+  };
+  const close = () => {
+    closed = true;
+    return closing ??= (async () => {
+      const results = await Promise.allSettled([response?.close(), mutation?.close(), pages?.close(), archive.close()]);
+      for (const result of results) if (result.status === "rejected") throw result.reason;
+    })();
+  };
+  try {
+    mutation = await openRetainedSlideSettings(archive, before, options, settings);
+    let size = input.size, fingerprint = before, start = 0;
+    if (mutation.changed) {
+      const working = settings.workingStorage;
+      pages = new PagedStorage2({ fs: working.fs, cwd: working.directory, env: {}, signal }, (working.cacheBytes ?? 1024 * 1024) / 16384);
+      start = pages.allocate(0);
+      size = 0;
+      const digest = sha256.create();
+      await archive.rewrite({ async write(bytes2) {
+        check();
+        for (let offset = 0; offset < bytes2.length; offset += 16384) {
+          check();
+          const owned = new Uint8Array(bytes2.subarray(offset, offset + 16384));
+          await pages.append(owned);
+          digest.update(owned);
+          size += owned.length;
+        }
+      } }, { replace: mutation.replacement });
+      fingerprint = hex(digest.digest());
+    }
+    async function* bytes() {
+      check();
+      if (!pages) {
+        yield* input.stream();
+        check();
+        return;
+      }
+      for (let offset = 0; offset < size; offset += 16384) {
+        check();
+        yield await pages.read(start + offset, Math.min(16384, size - offset));
+      }
+      check();
+    }
+    async function* locations() {
+      for await (const location of mutation.targets()) yield { ...location, fingerprint };
+    }
+    async function* effects() {
+      if (fingerprint !== before) for await (const location of locations()) yield { location, action: "update", feature: "F07" };
+    }
+    const dryRun = output.dryRun;
+    async function* content() {
+      if (output.destination === "-" && !dryRun) {
+        yield* bytes();
+        return;
+      }
+      if (output.json) {
+        yield* streamJson({ version: 1, operation: "slides.set", ok: true, data: {
+          effects: effects(),
+          outputs: dryRun ? [] : [{ path: output.destination, sha256: fingerprint, bytes: size }],
+          fingerprint: dryRun ? null : fingerprint
+        }, warnings: [], errors: [], affected: mutation.affected, locations: locations() });
+        yield new TextEncoder().encode("\n");
+      } else yield new TextEncoder().encode(`${dryRun ? "Validated" : "Updated"} ${mutation.affected} slide(s)
+`);
+    }
+    response = await stageRetainedOutput(content(), settings, output.maxOutputBytes);
+    return Object.freeze({ bytes, size, fingerprint, output: response, close });
+  } catch (error) {
+    await close().catch(() => {
+    });
+    throw error;
+  }
+}
 
 // packages/safe-bash-presentation-engine/src/slides.ts
 var contentNamespace = "http://schemas.openxmlformats.org/package/2006/content-types";
@@ -51,7 +441,7 @@ var dialects = [
 function invalid(message) {
   throw new OfficeError("invalid-value", message, "usage");
 }
-function unsupported(message) {
+function unsupported2(message) {
   throw new OfficeError("unsupported-edit", message, "validate-intent");
 }
 function attr(node, name, namespace = "") {
@@ -78,16 +468,16 @@ function fields(value, allowed) {
   if (!value || typeof value !== "object" || ![Object.prototype, null].includes(Object.getPrototypeOf(value)) || Object.keys(value).some((key) => !allowed.includes(key)))
     invalid("Expected a structured slide insertion object.");
 }
-function escape(text, maximum) {
+function* escapedSlideText(text, maximum) {
   if (typeof text !== "string") invalid("Expected text.");
   if (text.length > maximum)
     throw new OfficeError("resource-limit", "Slide text exceeds limits.", "usage");
-  let result = "";
+  let length = 0;
   for (const ch of text) {
     const code = ch.codePointAt(0);
     if (code < 32 && ![9, 10, 13].includes(code) || code >= 55296 && code <= 57343 || code === 65534 || code === 65535)
       invalid("Text contains an invalid XML character.");
-    result += {
+    const value = {
       "&": "&amp;",
       "<": "&lt;",
       ">": "&gt;",
@@ -96,9 +486,15 @@ function escape(text, maximum) {
       "\n": "&#10;",
       "	": "&#9;"
     }[ch] ?? ch;
-    if (result.length > maximum)
+    length += value.length;
+    if (length > maximum)
       throw new OfficeError("resource-limit", "Slide text exceeds limits.", "usage");
+    yield value;
   }
+}
+function escape(text, maximum) {
+  let result = "";
+  for (const value of escapedSlideText(text, maximum)) result += value;
   return result;
 }
 function relationshipPart(owner) {
@@ -180,13 +576,13 @@ function prepareSlideInsertion(reader, options, context) {
     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/"))
-      unsupported("Signed and macro-enabled packages cannot be changed.");
+      unsupported2("Signed and macro-enabled packages cannot be changed.");
   }
   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.");
+      unsupported2("Signed and macro-enabled packages cannot be changed.");
   if (!validatePresentation(reader, validationLimits).valid)
     throw new OfficeError(
       "invalid-opc",
@@ -200,9 +596,9 @@ function prepareSlideInsertion(reader, options, context) {
   while (presentationNodes.length) {
     const node = presentationNodes.pop();
     if (node.name.namespace === d.p && node.name.localName === "modifyVerifier")
-      unsupported("Protected presentations cannot be changed.");
+      unsupported2("Protected presentations cannot be changed.");
     if (node.name.namespace === "http://schemas.openxmlformats.org/markup-compatibility/2006")
-      unsupported("Conditional presentation structure cannot be changed.");
+      unsupported2("Conditional presentation structure cannot be changed.");
     presentationNodes.push(...node.children);
   }
   const list = child(presentation.root, "sldIdLst", d.p);
@@ -211,7 +607,7 @@ function prepareSlideInsertion(reader, options, context) {
   ) ?? [];
   const position = options.position ?? ids.length + 1;
   if (position > ids.length + 1) invalid("Insertion position is outside the slide list.");
-  if (list && ids.length !== list.children.length) unsupported("Unsupported slide-list content.");
+  if (list && ids.length !== list.children.length) unsupported2("Unsupported slide-list content.");
   const candidates = graph.parts.filter((name) => types.get(name) === `${typePrefix}slideLayout+xml`).filter((name) => {
     if (options.layout.startsWith("/")) return name === options.layout;
     const document = parseXmlPart(reader.get(name), context.xmlLimits);
@@ -226,7 +622,7 @@ function prepareSlideInsertion(reader, options, context) {
   const layout = candidates[0];
   const layoutDocument = parseXmlPart(reader.get(layout), context.xmlLimits);
   if (layoutDocument.root.name.namespace !== d.p)
-    unsupported("Layout dialect must match the presentation.");
+    unsupported2("Layout dialect must match the presentation.");
   const masters = graph.outgoing(layout).filter((edge) => edge.type === `${d.r}/slideMaster` && !edge.external);
   const masterEdges = graph.outgoing(main).filter(
     (edge) => edge.type === `${d.r}/slideMaster` && edge.targetPart === masters[0]?.targetPart
@@ -244,12 +640,12 @@ function prepareSlideInsertion(reader, options, context) {
   const placeholders = [];
   const keys = /* @__PURE__ */ new Set();
   for (const node of tree.children) {
-    if (node.name.namespace !== d.p) unsupported("Unsupported layout drawing content.");
+    if (node.name.namespace !== d.p) unsupported2("Unsupported layout drawing content.");
     if (node.name.localName !== "sp") {
       if (!["nvGrpSpPr", "grpSpPr", "pic", "graphicFrame", "cxnSp", "grpSp"].includes(
         node.name.localName
       ))
-        unsupported("Unsupported layout drawing content.");
+        unsupported2("Unsupported layout drawing content.");
       continue;
     }
     const nv = child(node, "nvSpPr", d.p);
@@ -277,7 +673,7 @@ function prepareSlideInsertion(reader, options, context) {
     if (ph.attributes.some(
       (attribute) => attribute.name.namespace || !["type", "idx", "sz", "orient", "hasCustomPrompt"].includes(attribute.name.localName)
     ))
-      unsupported("Unsupported placeholder attributes.");
+      unsupported2("Unsupported placeholder attributes.");
     placeholders.push({
       type,
       index,
@@ -314,7 +710,7 @@ function prepareSlideInsertion(reader, options, context) {
         "select"
       );
     if (!textPlaceholderTypes.includes(matches[0].type))
-      unsupported("Rich-content placeholders cannot be populated as text.");
+      unsupported2("Rich-content placeholders cannot be populated as text.");
     assigned.add(matches[0]);
     matches[0].text = assignment.text;
   }
@@ -416,7 +812,7 @@ function prepareSlideInsertion(reader, options, context) {
     );
   return { changes, part: slide, slideId, position };
 }
-async function mutateSlides(input, options, context) {
+function prepareSlideMutationOptions(options, context) {
   fields(options, ["selection", "position", "name", "hidden", "allowEmpty"]);
   if ([options.position, options.name, options.hidden].every((value) => value === void 0))
     invalid("At least one slide update is required.");
@@ -429,7 +825,7 @@ async function mutateSlides(input, options, context) {
       invalid("Expected a boolean slide setting.");
   if (!context?.xmlLimits || !context.relationshipLimits)
     invalid("Explicit XML and relationship limits are required.");
-  if (options.name !== void 0) escape(options.name, context.xmlLimits.maxBytes);
+  if (options.name !== void 0) for (const value of escapedSlideText(options.name, context.xmlLimits.maxBytes)) void value;
   const queries = Array.isArray(options.selection) ? options.selection : [options.selection];
   if (!queries.length) throw new SelectionError("invalid-selection");
   if (queries.length > context.relationshipLimits.maxParts)
@@ -437,6 +833,10 @@ async function mutateSlides(input, options, context) {
   for (const query of queries)
     if (!query || typeof query !== "object" || query.kind !== void 0 && query.kind !== "slide" || query.scope !== void 0 && query.scope !== "slides" || !query.all && query.token === void 0 && query.id === void 0 && query.name === void 0 && query.position === void 0)
       throw new SelectionError("invalid-selection");
+  return queries;
+}
+async function mutateSlides(input, options, context) {
+  const queries = prepareSlideMutationOptions(options, context);
   const source = await readBinary(input, context);
   const reader = await readPackage(source, context);
   const limits = {
@@ -452,13 +852,13 @@ async function mutateSlides(input, options, context) {
     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/"))
-      unsupported("Signed and macro-enabled packages cannot be changed.");
+      unsupported2("Signed and macro-enabled packages cannot be changed.");
   }
   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.");
+      unsupported2("Signed and macro-enabled packages cannot be changed.");
   if (!validatePresentation(reader, limits).valid)
     throw new OfficeError(
       "invalid-opc",
@@ -493,16 +893,16 @@ async function mutateSlides(input, options, context) {
   while (pending.length) {
     const node = pending.pop();
     if (node.name.namespace === d.p && node.name.localName === "modifyVerifier")
-      unsupported("Protected presentations cannot be changed.");
+      unsupported2("Protected presentations cannot be changed.");
     if (node.name.namespace === "http://schemas.openxmlformats.org/markup-compatibility/2006")
-      unsupported("Conditional presentation structure cannot be changed.");
+      unsupported2("Conditional presentation structure cannot be changed.");
     pending.push(...node.children);
   }
   const changes = /* @__PURE__ */ new Map();
   if (selected.length && options.position !== void 0) {
     const list = child(presentation.root, "sldIdLst", d.p);
     if (list.children.some((node) => node.name.namespace !== d.p || node.name.localName !== "sldId"))
-      unsupported("Unsupported slide-list content.");
+      unsupported2("Unsupported slide-list content.");
     const ordered = index.slides.filter((slide) => !identities.has(slide.id));
     ordered.splice(options.position - 1, 0, ...selected);
     if (ordered.some((slide, i) => slide.id !== index.slides[i].id)) {
@@ -520,7 +920,7 @@ async function mutateSlides(input, options, context) {
     let changed = false;
     if (options.name !== void 0) {
       const common = child(document.root, "cSld", d.p);
-      if (!common) unsupported("Conditional slide labels cannot be changed.");
+      if (!common) unsupported2("Conditional slide labels cannot be changed.");
       if ((attr(common, "name") ?? "") !== options.name) {
         document = document.merge(common, {
           attributes: [{ namespace: "", localName: "name", value: options.name || null }]
@@ -560,7 +960,10 @@ async function mutateSlides(input, options, context) {
 }
 
 export {
+  openRetainedSlideSettings,
+  stageRetainedSlideSettings,
   addSlide,
   prepareSlideInsertion,
+  prepareSlideMutationOptions,
   mutateSlides
 };

package/dist/safe-bash/command-chunks/{chunk-DC3OJLRB.js → chunk-NQDIT667.js}

@@ -4,20 +4,20 @@ import {
   escape,
   invalid,
   loadShared
-} from "./chunk-ORZRWT62.js";
+} from "./chunk-56NYSX65.js";
 import {
   SelectionError,
   decodeSelectionToken
-} from "./chunk-S4IIOSRA.js";
+} from "./chunk-X7FA7ZD5.js";
 import {
   parseXmlPart
-} from "./chunk-5L6GHFRW.js";
+} from "./chunk-554Z6IKP.js";
 import {
   partName
-} from "./chunk-AXWPJRY6.js";
+} from "./chunk-36XGIPOG.js";
 import {
   OfficeError
-} from "./chunk-KJ3PEDI2.js";
+} from "./chunk-Q73EMLLZ.js";
 
 // packages/safe-bash-presentation-engine/src/animation-editing.ts
 import { SaxesParser } from "saxes";