@poe-platform/safe-bash 0.1.809 → 0.1.811

package/dist/safe-bash/command-chunks/{chunk-6OKH4X67.js → chunk-KJ4XXZIL.js}

@@ -1,30 +1,46 @@
+import {
+  openRetainedPresentationIndex,
+  stageRetainedOutput,
+  streamJson
+} from "./chunk-L5MCW6CM.js";
 import {
   writePackageArchive
-} from "./chunk-VPDSQPSN.js";
+} from "./chunk-DM2CPMB4.js";
+import {
+  SelectionError
+} 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 {
   validatePresentation
-} from "./chunk-MMBRBANA.js";
+} from "./chunk-RNSKXOG3.js";
+import {
+  openRetainedContentTypes
+} 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 {
+  packageUri,
   partName
-} from "./chunk-AXWPJRY6.js";
+} from "./chunk-36XGIPOG.js";
 import {
-  OfficeError
-} from "./chunk-KJ3PEDI2.js";
+  OfficeError,
+  characters,
+  literal,
+  openRetainedXml,
+  openRetainedXmlDocument
+} from "./chunk-Q73EMLLZ.js";
 
 // packages/safe-bash-presentation-engine/src/xml-view-validation.ts
 function reject() {
@@ -144,6 +160,251 @@ function validateXmlViewReplacement(reader, part, bytes, context, validate) {
 
 // packages/safe-bash-presentation-engine/src/xml-parts.ts
 import { SaxesParser } from "saxes";
+
+// packages/safe-bash-presentation-engine/src/retained-xml-parts.ts
+import { PagedStorage } from "@poe-platform/safe-fs/storage";
+async function prettySpans(xml, settings) {
+  const working = settings.workingStorage, signal = settings.signal ?? new AbortController().signal;
+  const pages = new PagedStorage({ fs: working.fs, cwd: working.directory, env: {}, signal }, (working.cacheBytes ?? 1024 * 1024) / 16384);
+  async function row(pointer) {
+    const bytes = await pages.read(pointer, 9 /* Count */ * 8), view = new DataView(bytes.buffer, bytes.byteOffset, bytes.byteLength);
+    return Array.from({ length: 9 /* Count */ }, (_, i) => view.getFloat64(i * 8, true));
+  }
+  async function save(pointer, row2) {
+    const bytes = new Uint8Array(9 /* Count */ * 8), view = new DataView(bytes.buffer);
+    row2.forEach((value, i) => view.setFloat64(i * 8, value, true));
+    await pages.write(pointer, bytes);
+  }
+  let current = 0, root = 0;
+  try {
+    for await (const token of xml.tokens()) {
+      if (token.kind === "start-name") {
+        const pointer = pages.allocate(9 /* Count */ * 8), value = Array(9 /* Count */).fill(0);
+        value[0 /* Parent */] = current;
+        value[4 /* Start */] = token.range.start - 1;
+        if (current) {
+          const parent = await row(current);
+          if (parent[2 /* Last */]) {
+            const previous = await row(parent[2 /* Last */]);
+            previous[3 /* Next */] = pointer;
+            await save(parent[2 /* Last */], previous);
+          } else parent[1 /* First */] = pointer;
+          parent[2 /* Last */] = pointer;
+          await save(current, parent);
+        } else root = pointer;
+        await save(pointer, value);
+        current = pointer;
+      } else if (token.kind === "start-end") {
+        const value = await row(current);
+        value[5 /* Open */] = token.range.start;
+        if (token.empty) value[7 /* End */] = token.range.start;
+        await save(current, value);
+        if (token.empty) current = value[0 /* Parent */];
+      } else if (token.kind === "end-name") {
+        const value = await row(current);
+        value[6 /* Close */] = token.range.start - 2;
+        let end = token.range.start + token.range.length;
+        outer: for await (const bytes of xml.read({ start: end, length: xml.byteLength - end })) for (const byte of bytes) {
+          end++;
+          if (byte === 62) break outer;
+        }
+        value[7 /* End */] = end;
+        await save(current, value);
+        current = value[0 /* Parent */];
+      } else if (current && ["text", "comment", "cdata", "instruction"].includes(token.kind)) {
+        let mixed = token.kind !== "text";
+        if (!mixed) {
+          for await (const character of characters(xml.value(token.range))) if (character.trim()) {
+            mixed = true;
+            break;
+          }
+        }
+        if (mixed) {
+          const value = await row(current);
+          value[8 /* Mixed */] = 1;
+          await save(current, value);
+        }
+      }
+    }
+    const formatted = !(await row(root))[8 /* Mixed */] && Boolean((await row(root))[1 /* First */]);
+    async function* indent(depth) {
+      yield* literal("\n");
+      const spaces = new Uint8Array(4096).fill(32);
+      for (let left = depth * 2; left; left -= Math.min(left, spaces.length)) yield spaces.subarray(0, Math.min(left, spaces.length));
+    }
+    async function* render() {
+      let pointer = root, depth = 0, returning = false;
+      while (pointer) {
+        signal.throwIfAborted();
+        const value = await row(pointer);
+        if (returning) {
+          yield* indent(depth);
+          yield* xml.read({ start: value[6 /* Close */], length: value[7 /* End */] - value[6 /* Close */] });
+        } else if (value[8 /* Mixed */] || !value[1 /* First */]) yield* xml.read({ start: value[4 /* Start */], length: value[7 /* End */] - value[4 /* Start */] });
+        else {
+          yield* xml.read({ start: value[4 /* Start */], length: value[5 /* Open */] - value[4 /* Start */] });
+          pointer = value[1 /* First */];
+          depth++;
+          yield* indent(depth);
+          continue;
+        }
+        if (value[3 /* Next */]) {
+          pointer = value[3 /* Next */];
+          returning = false;
+          yield* indent(depth);
+        } else {
+          pointer = value[0 /* Parent */];
+          depth--;
+          returning = true;
+        }
+      }
+    }
+    return { formatted, render, close: () => pages.close() };
+  } catch (error) {
+    await pages.close().catch(() => {
+    });
+    throw error;
+  }
+}
+async function openRetainedXmlPart(archive, requested, settings, 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");
+  settings = { ...settings, workingStorage: { ...settings.workingStorage }, ...settings.validationLimits ? { validationLimits: { ...settings.validationLimits } } : {} };
+  const pretty2 = options.pretty ?? false, part = partName(requested, false), limits = settings.validationLimits;
+  if (!limits) throw new OfficeError("invalid-value", "XML operations require explicit validation limits.", "usage");
+  if (part !== requested || !await archive.has(part)) throw new OfficeError("missing-selection", "An exact existing package part is required.", "select");
+  if (part !== "/[Content_Types].xml") {
+    const types = await openRetainedContentTypes(archive.read("/[Content_Types].xml"), { ...settings, xmlLimits: { maxBytes: limits.maxBytes, maxNodes: Infinity, maxDepth: Infinity } }, limits);
+    let failed = false;
+    try {
+      let prefix = "", suffix = "";
+      for await (const character of characters(await types.get(part))) {
+        if (character === ";") break;
+        if (!character.trim()) continue;
+        if (prefix.length < 16) prefix += character.toLowerCase();
+        suffix = (suffix + character.toLowerCase()).slice(-4);
+      }
+      if (prefix !== "application/xml" && prefix !== "text/xml" && suffix !== "+xml") throw new OfficeError("unsupported-profile", "The selected part is not XML.", "select");
+    } catch (error) {
+      failed = true;
+      throw error;
+    } finally {
+      try {
+        await types.close();
+      } catch (error) {
+        if (!failed) await Promise.reject(error);
+      }
+    }
+  }
+  const context = { ...settings, xmlLimits: limits };
+  const document = await openRetainedXmlDocument(archive.read(part), context);
+  await document.close();
+  const xml = await openRetainedXml(archive.read(part), context);
+  let spans, closed = false, closing;
+  const check = () => {
+    if (closed) throw new OfficeError("invalid-handle", "XML part is closed.", "select");
+    if (settings.signal?.aborted) throw new OfficeError("cancelled", "Operation cancelled.", "select");
+  };
+  const close = () => {
+    closed = true;
+    return closing ??= (async () => {
+      const results = await Promise.allSettled([xml.close(), spans?.close()]);
+      for (const result of results) if (result.status === "rejected") throw result.reason;
+    })();
+  };
+  try {
+    if (pretty2) spans = await prettySpans(xml, context);
+    return Object.freeze({
+      part,
+      format: pretty2 ? "pretty" : "original",
+      close,
+      async *bytes() {
+        check();
+        for await (const bytes of archive.read(part)) {
+          check();
+          yield bytes;
+        }
+        check();
+      },
+      async *xml() {
+        check();
+        const source = spans ? spans.render() : xml.read({ start: 0, length: xml.byteLength });
+        let count = 0;
+        for await (const bytes of source) {
+          check();
+          count += bytes.length;
+          if (spans?.formatted && count > limits.maxBytes) throw new OfficeError("resource-limit", "Pretty XML byte limit exceeded.", "serialize");
+          yield bytes;
+        }
+        check();
+      }
+    });
+  } catch (error) {
+    await close().catch(() => {
+    });
+    throw error;
+  }
+}
+async function stageRetainedXmlPart(archive, fingerprint, selection, settings, output) {
+  const options = { ...selection }, format = { ...output }, index = await openRetainedPresentationIndex(archive, fingerprint, settings);
+  let xml, staged;
+  try {
+    let metadata = false;
+    if (options.scope === "shared" && options.part) {
+      metadata = options.part === "/[Content_Types].xml" || options.part === packageUri("/").relsUri;
+      if (!metadata) {
+        for await (const record2 of index.records.records("part")) if (packageUri(record2.part).relsUri === options.part) {
+          metadata = true;
+          break;
+        }
+      }
+    }
+    async function* selected() {
+      if (options.token) {
+        yield* index.records.select({ token: options.token });
+        return;
+      }
+      const scope = options.scope ?? "slides", all = options.all ?? false;
+      if (options.slide !== void 0) for await (const slide of index.records.select({ kind: "slide", position: { coordinateSystem: "one-based", value: options.slide } })) {
+        if (options.shape) yield* index.records.select({ kind: "object", owner: slide.part, name: options.shape, scope, all });
+        else yield slide;
+      }
+      else if (options.part) yield* index.records.select(options.shape ? { kind: "object", owner: options.part, name: options.shape, scope, all } : { kind: "part", part: options.part, scope, all });
+      else if (scope === "slides") yield* index.records.records("slide");
+      else for await (const record2 of index.records.records("part")) if (record2.location.scope === scope) yield record2;
+    }
+    let record, count = 0;
+    if (!metadata) {
+      for await (const item of selected()) {
+        record = item;
+        count++;
+      }
+      if (count !== 1 || record.kind === "object") throw new SelectionError("invalid-selection");
+    }
+    const part = metadata ? options.part : record.part;
+    const location = metadata ? { fingerprint, scope: "shared", owner: part, objectId: part, coordinateSystem: "identity" } : record.location;
+    xml = await openRetainedXmlPart(archive, part, settings, { pretty: format.pretty ?? false });
+    const data = xml;
+    async function* render() {
+      if (format.json) {
+        yield* streamJson({ version: 1, operation: "xml.get", ok: true, data: { part, format: data.format, xml: data.xml }, warnings: [], errors: [], affected: 0, locations: [location] });
+        yield* literal("\n");
+      } else if (format.pretty) {
+        yield* literal("Pretty XML (not original bytes)\n");
+        yield* data.xml();
+        yield* literal("\n");
+      } else yield* data.bytes();
+    }
+    staged = await stageRetainedOutput(render(), settings, format.maxOutputBytes);
+    await xml.close();
+    await index.close();
+    return staged;
+  } catch (error) {
+    await Promise.allSettled([xml?.close(), index.close(), staged?.close()]);
+    throw error;
+  }
+}
+
+// packages/safe-bash-presentation-engine/src/xml-parts.ts
 var namespaces = [
   "http://schemas.openxmlformats.org/presentationml/2006/main",
   "http://purl.oclc.org/ooxml/presentationml/main"
@@ -449,6 +710,8 @@ function validateXmlPartReplacement(reader, part, bytes, context) {
 
 export {
   validateXmlViewReplacement,
+  openRetainedXmlPart,
+  stageRetainedXmlPart,
   getXmlPart,
   replaceXmlPart,
   validateXmlPartReplacement