@poe-platform/safe-bash 0.1.809 → 0.1.810

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

@@ -1,6 +1,14 @@
+import {
+  openRetainedPresentationIndex,
+  stageRetainedOutput,
+  streamJson
+} from "./chunk-U6QHTC5J.js";
 import {
   writePackageArchive
 } from "./chunk-VPDSQPSN.js";
+import {
+  SelectionError
+} from "./chunk-S4IIOSRA.js";
 import {
   readPackage
 } from "./chunk-SFCERNHU.js";
@@ -10,6 +18,9 @@ import {
 import {
   validatePresentation
 } from "./chunk-MMBRBANA.js";
+import {
+  openRetainedContentTypes
+} from "./chunk-FXKBM5KJ.js";
 import {
   parseXmlPart
 } from "./chunk-5L6GHFRW.js";
@@ -20,10 +31,15 @@ import {
   readRelationshipGraph
 } from "./chunk-NTRZMQZP.js";
 import {
+  packageUri,
   partName
 } from "./chunk-AXWPJRY6.js";
 import {
-  OfficeError
+  OfficeError,
+  characters,
+  literal,
+  openRetainedXml,
+  openRetainedXmlDocument
 } from "./chunk-KJ3PEDI2.js";
 
 // packages/safe-bash-presentation-engine/src/xml-view-validation.ts
@@ -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

package/dist/safe-bash/command-chunks/{chunk-YJJBGN7U.js → chunk-CHR2OD2U.js}

@@ -2,7 +2,7 @@ import {
   g
 } from "./chunk-Z7ESJVFP.js";
 
-// packages/safe-bash-command-ssconvert/dist/chunks/chunk-LMJ46OBK.js
+// packages/safe-bash-command-ssconvert/dist/chunks/chunk-GL2HE4HF.js
 import { createEngine as vt } from "../../spreadsheet-engine/index.js";
 import { SsconvertError as O } from "../../spreadsheet-engine/contracts.js";
 import { decodeTextSource as ot } from "../../spreadsheet-engine/encoding/decode-source.js";
@@ -35,13 +35,13 @@ var te = { id: "Gnumeric_applix", services: [{ id: "applix", direction: "read",
 var re = { id: "Gnumeric_dif", services: [{ id: "dif", direction: "read", read: async (e, t) => (await import("./dif-BXKPQOCO-4KB3RC6G.js")).readDif(e, t), description: "Data Interchange Format (*.dif)", extensions: ["dif"], probePriority: 1 }, { id: "dif", direction: "write", write: async (e, t, i) => (await import("./dif-BXKPQOCO-4KB3RC6G.js")).writeDif(e, t, i), description: "Data Interchange Format (*.dif)", extensions: ["dif"], formatLevel: "manual_remember", saveScope: "sheet", selectionSource: "view" }], source: "plugins/dif/plugin.xml.in" };
 var Qe = ["xor", "rc4", ...[false, true].flatMap((e) => [40, 48, 56, 64, 72, 80, 88, 96, 104, 112, 120, 128].map((t) => `rc4-cryptoapi-${t}${e ? "-properties" : ""}`))];
 var ie = ["xor"];
-var W = { id: "Gnumeric_Excel", source: "plugins/excel/plugin.xml.in", services: [{ id: "excel", direction: "read", readWorkbookSource: async (...e) => (await import("./biff-DS263V2K-2GP4GZT7.js")).readBiffWorkbookSource(...e), readSource: async (...e) => (await import("./biff-DS263V2K-2GP4GZT7.js")).readBiff(...e), probeSource: async (...e) => (await import("./biff-DS263V2K-2GP4GZT7.js")).probeBiff(...e), read: async (...e) => (await import("./biff-DS263V2K-2GP4GZT7.js")).readBiff(...e), probeContent: async (...e) => (await import("./biff-DS263V2K-2GP4GZT7.js")).probeBiff(...e), description: "MS Excel\u2122 (*.xls)", extensions: ["xls", "xlw", "xlt"], mimeTypes: ["application/vnd.ms-excel", "application/excel", "application/msexcel", "application/x-excel", "application/x-ms-excel", "application/x-msexcel", "application/x-xls", "application/xls", "application/x-dos_ms_excel", "zz-application/zz-winassoc-xls"], probePriority: 100, contentProbe: true }, { id: "excel_biff8", write: async (...e) => (await import("./biff-DS263V2K-2GP4GZT7.js")).createBiffWriter(8)(...e), writeStream: async function* (...e) {
-  yield* (await import("./biff-DS263V2K-2GP4GZT7.js")).createBiffStreamWriter(8)(...e);
-}, labelRanges: true, exportOptionRules: { encryption: { kind: "enum", values: Qe } }, direction: "write", description: "MS Excel\u2122 97/2000/XP", extensions: ["xls"], mimeTypes: ["application/vnd.ms-excel"], formatLevel: "auto", defaultSaverPriority: 1 }, { id: "excel_biff7", write: async (...e) => (await import("./biff-DS263V2K-2GP4GZT7.js")).createBiffWriter(7)(...e), writeStream: async function* (...e) {
-  yield* (await import("./biff-DS263V2K-2GP4GZT7.js")).createBiffStreamWriter(7)(...e);
-}, labelRanges: true, exportOptionRules: { encryption: { kind: "enum", values: ie } }, direction: "write", description: "MS Excel\u2122 5.0/95", extensions: ["xls"], mimeTypes: ["application/vnd.ms-excel"], formatLevel: "auto" }, { id: "excel_dsf", write: async (...e) => (await import("./biff-DS263V2K-2GP4GZT7.js")).createBiffWriter("dsf")(...e), writeStream: async function* (...e) {
-  yield* (await import("./biff-DS263V2K-2GP4GZT7.js")).createBiffStreamWriter("dsf")(...e);
-}, labelRanges: true, exportOptionRules: { encryption: { kind: "enum", values: ie } }, direction: "write", description: "MS Excel\u2122 97/2000/XP & 5.0/95", extensions: ["xls"], mimeTypes: ["application/vnd.ms-excel"], formatLevel: "auto" }, { id: "excel_enc", direction: "read", read: async (...e) => (await import("./biff-DS263V2K-2GP4GZT7.js")).readBiff(...e), description: "MS Excel\u2122 (*.xls) requiring encoding specification", extensions: [], probePriority: 200, encodingDependent: true }] };
+var W = { id: "Gnumeric_Excel", source: "plugins/excel/plugin.xml.in", services: [{ id: "excel", direction: "read", readWorkbookSource: async (...e) => (await import("./biff-ORSHM4YX-QYPGRDAZ.js")).readBiffWorkbookSource(...e), readSource: async (...e) => (await import("./biff-ORSHM4YX-QYPGRDAZ.js")).readBiff(...e), probeSource: async (...e) => (await import("./biff-ORSHM4YX-QYPGRDAZ.js")).probeBiff(...e), read: async (...e) => (await import("./biff-ORSHM4YX-QYPGRDAZ.js")).readBiff(...e), probeContent: async (...e) => (await import("./biff-ORSHM4YX-QYPGRDAZ.js")).probeBiff(...e), description: "MS Excel\u2122 (*.xls)", extensions: ["xls", "xlw", "xlt"], mimeTypes: ["application/vnd.ms-excel", "application/excel", "application/msexcel", "application/x-excel", "application/x-ms-excel", "application/x-msexcel", "application/x-xls", "application/xls", "application/x-dos_ms_excel", "zz-application/zz-winassoc-xls"], probePriority: 100, contentProbe: true }, { id: "excel_biff8", write: async (...e) => (await import("./biff-ORSHM4YX-QYPGRDAZ.js")).createBiffWriter(8)(...e), writeStream: async function* (...e) {
+  yield* (await import("./biff-ORSHM4YX-QYPGRDAZ.js")).createBiffStreamWriter(8)(...e);
+}, labelRanges: true, exportOptionRules: { encryption: { kind: "enum", values: Qe } }, direction: "write", description: "MS Excel\u2122 97/2000/XP", extensions: ["xls"], mimeTypes: ["application/vnd.ms-excel"], formatLevel: "auto", defaultSaverPriority: 1 }, { id: "excel_biff7", write: async (...e) => (await import("./biff-ORSHM4YX-QYPGRDAZ.js")).createBiffWriter(7)(...e), writeStream: async function* (...e) {
+  yield* (await import("./biff-ORSHM4YX-QYPGRDAZ.js")).createBiffStreamWriter(7)(...e);
+}, labelRanges: true, exportOptionRules: { encryption: { kind: "enum", values: ie } }, direction: "write", description: "MS Excel\u2122 5.0/95", extensions: ["xls"], mimeTypes: ["application/vnd.ms-excel"], formatLevel: "auto" }, { id: "excel_dsf", write: async (...e) => (await import("./biff-ORSHM4YX-QYPGRDAZ.js")).createBiffWriter("dsf")(...e), writeStream: async function* (...e) {
+  yield* (await import("./biff-ORSHM4YX-QYPGRDAZ.js")).createBiffStreamWriter("dsf")(...e);
+}, labelRanges: true, exportOptionRules: { encryption: { kind: "enum", values: ie } }, direction: "write", description: "MS Excel\u2122 97/2000/XP & 5.0/95", extensions: ["xls"], mimeTypes: ["application/vnd.ms-excel"], formatLevel: "auto" }, { id: "excel_enc", direction: "read", read: async (...e) => (await import("./biff-ORSHM4YX-QYPGRDAZ.js")).readBiff(...e), description: "MS Excel\u2122 (*.xls) requiring encoding specification", extensions: [], probePriority: 200, encodingDependent: true }] };
 var oe = { id: "Gnumeric_Excel", source: "plugins/excel/plugin.xml.in", services: [{ id: "xlsx", direction: "read", probeContent: async (e, t) => (await import("./xlsx-RE54MFCS-DI3F765V.js")).probeXlsx(e, t), probeSource: async (e, t) => (await import("./xlsx-RE54MFCS-DI3F765V.js")).probeXlsx(e, t), readWorkbookSource: async (e, t) => (await import("./xlsx-RE54MFCS-DI3F765V.js")).readXlsx(e, t, true), readSource: async (e, t) => (await import("./xlsx-RE54MFCS-DI3F765V.js")).readXlsx(e, t), read: async (e, t) => (await import("./xlsx-RE54MFCS-DI3F765V.js")).readXlsx(e, t), description: "ECMA 376 / Office Open XML [MS Excel\u2122 2007/2010] (*.xlsx)", extensions: ["xlsx", "xltx", "xlsb", "xlsm", "xltm"], mimeTypes: ["application/vnd.openxmlformats-officedocument.spreadsheetml.sheet", "application/vnd.openxmlformats-officedocument.spreadsheetml.template"], probePriority: 100, contentProbe: true }, { id: "xlsx", direction: "write", sourceAxes: true, write: async (e, t, i) => (await import("./xlsx-RE54MFCS-DI3F765V.js")).createXlsxWriter("2006")(e, t, i), writeStream: async function* (e, t, i) {
   yield* (await import("./xlsx-RE54MFCS-DI3F765V.js")).createXlsxStreamWriter("2006")(e, t, i);
 }, writeWorkbookSource: async function* (e, t, i) {
@@ -72,7 +72,7 @@ var j = { id: "Gnumeric_OpenCalc", services: [{ id: "openoffice", direction: "re
   yield* (await import("./odf-3EA3EVSD-7B5GVNTC.js")).createOdfStreamWriter("extended")(e, t, i);
 }, labelRanges: true, exportOptionRules: { encryption: { kind: "enum", values: pe } }, description: "ODF 1.2 extended conformance (*.ods)", extensions: ["ods"], mimeTypes: ["application/vnd.oasis.opendocument.spreadsheet"], formatLevel: "auto" }], source: "plugins/openoffice/plugin.xml.in" };
 var fe = { id: "Gnumeric_paradox", services: [{ id: "paradox", direction: "read", read: async (e, t) => (await import("./paradox-ZWWXYY4J-JYOSWSBL.js")).readParadox(e, t), description: "Paradox database or primary index file (*.db, *.px)", extensions: ["db", "px"], probePriority: 100 }, { id: "paradox", direction: "write", write: async (e, t, i) => (await import("./paradox-ZWWXYY4J-JYOSWSBL.js")).writeParadox(e, t, i), exportOptionRules: { encryption: { kind: "enum", values: ["paradox"] } }, description: "Paradox database (*.db)", extensions: ["db"] }], source: "plugins/paradox/plugin.xml.in" };
-var xe = { id: "Gnumeric_pdf", source: "src/print-info.c:1074", services: [{ id: "pdf_assistant", direction: "write", description: "PDF export", extensions: ["pdf"], sheetSelection: true, honorsExportRange: false, write: async (...e) => (await import("./pdf-T7AWYZGQ-KNAYJ7YF.js")).writePdf(...e), exportOptions: async (...e) => (await import("./pdf-T7AWYZGQ-KNAYJ7YF.js")).pdfExportOptions(...e), exportOptionRules: { object: { kind: "string" }, paper: { kind: "string" } } }] };
+var xe = { id: "Gnumeric_pdf", source: "src/print-info.c:1074", services: [{ id: "pdf_assistant", direction: "write", description: "PDF export", extensions: ["pdf"], sheetSelection: true, honorsExportRange: false, write: async (...e) => (await import("./pdf-LOZAXXS6-ERI57IAV.js")).writePdf(...e), exportOptions: async (...e) => (await import("./pdf-LOZAXXS6-ERI57IAV.js")).pdfExportOptions(...e), exportOptionRules: { object: { kind: "string" }, paper: { kind: "string" } } }] };
 var we = { id: "Gnumeric_plan_perfect", services: [{ id: "pln", direction: "read", probeContent: async (e, t) => (await import("./pln-DFS7VLVS-JATX6FS7.js")).probePln(e, t), read: async (e, t) => (await import("./pln-DFS7VLVS-JATX6FS7.js")).readPln(e, t), description: "Plan Perfect Format (PLN) import", extensions: ["pln"], mimeTypes: ["application/x-planperfect"], probePriority: 1, contentProbe: true }], source: "plugins/plan-perfect/plugin.xml.in" };
 var ye = { id: "Gnumeric_psiconv", services: [{ id: "psiconv", direction: "read", probeContent: async (e, t) => (await import("./psion-YBI6JEQI-6OMC2PGC.js")).probePsion(e, t), read: async (e, t) => (await import("./psion-YBI6JEQI-6OMC2PGC.js")).readPsion(e, t), description: "Psion (*.psisheet)", extensions: ["psisheet"], probePriority: 100, contentProbe: true }], source: "plugins/psiconv/plugin.xml.in" };
 var he = { id: "Gnumeric_QPro", services: [{ id: "qpro", direction: "read", probeContent: async (e, t) => (await import("./qpro-WLWWL7C3-XZ5DBS44.js")).probeQpro(e, t), read: async (e, t) => (await import("./qpro-WLWWL7C3-XZ5DBS44.js")).readQpro(e, t), description: "Quattro Pro (*.wb1, *.wb2, *.wb3)", extensions: ["wb1", "wb2", "wb3"], mimeTypes: ["application/x-quattropro", "application/x-quattro-pro"], probePriority: 100, contentProbe: true }], source: "plugins/qpro/plugin.xml.in" };

package/dist/safe-bash/command-chunks/{chunk-D7XBUF76.js → chunk-D2ASPM7R.js}

@@ -83,6 +83,68 @@ async function attributes(element, inherited, budget, exclusive) {
   });
   return selected;
 }
+var StoredFrames = class {
+  constructor(document) {
+    this.document = document;
+  }
+  document;
+  head = 0;
+  namespaces = /* @__PURE__ */ new WeakMap();
+  async store(value) {
+    const bytes = new TextEncoder().encode(JSON.stringify(value));
+    const header = new Uint8Array(8);
+    new DataView(header.buffer).setFloat64(0, bytes.length, true);
+    const reference = await this.document.storage.append(header);
+    await this.document.storage.append(bytes);
+    return reference;
+  }
+  async load(reference) {
+    const size = await this.document.storage.read(reference, 8);
+    const length = new DataView(size.buffer, size.byteOffset, 8).getFloat64(0, true);
+    return JSON.parse(new TextDecoder().decode(await this.document.storage.read(reference + 8, length)));
+  }
+  async push(source) {
+    let reversed = 0;
+    for await (const frame of source) {
+      const checkpoint = this.document.budget.tick();
+      if (checkpoint) await checkpoint;
+      let namespaces = this.namespaces.get(frame.namespaces);
+      if (namespaces === void 0) {
+        namespaces = await this.store([...frame.namespaces]);
+        this.namespaces.set(frame.namespaces, namespaces);
+      }
+      const value = await this.store({ ...frame, namespaces });
+      const link = new Uint8Array(16), view = new DataView(link.buffer);
+      view.setFloat64(0, reversed, true);
+      view.setFloat64(8, value, true);
+      reversed = await this.document.storage.append(link);
+    }
+    while (reversed) {
+      const checkpoint = this.document.budget.tick();
+      if (checkpoint) await checkpoint;
+      const link = await this.document.storage.read(reversed, 8);
+      const view = new DataView(link.buffer, link.byteOffset, 8), previous = view.getFloat64(0, true);
+      view.setFloat64(0, this.head, true);
+      await this.document.storage.write(reversed, link);
+      this.head = reversed;
+      reversed = previous;
+    }
+  }
+  async pop() {
+    if (!this.head) return void 0;
+    const link = await this.document.storage.read(this.head, 16);
+    const view = new DataView(link.buffer, link.byteOffset, 16);
+    this.head = view.getFloat64(0, true);
+    const frame = await this.load(view.getFloat64(8, true));
+    const namespaces = new Map(await this.load(frame.namespaces));
+    this.namespaces.set(namespaces, frame.namespaces);
+    return { ...frame, namespaces };
+  }
+};
+function* indentation(depth) {
+  yield "\n";
+  for (let left = depth; left > 0; left -= 2048) yield "  ".repeat(Math.min(left, 2048));
+}
 async function* serializeDocument(source, mode, budget, format = mode === "format", options = {}) {
   const stored = source instanceof StoredXmlDocument ? source : void 0;
   const rootReference = stored ? stored.root : source;
@@ -100,16 +162,26 @@ async function* serializeDocument(source, mode, budget, format = mode === "forma
   const documentDeclaration = options.declaration ?? root.declaration;
   const escaping = { canonical, ascii: !canonical && !documentDeclaration?.includes("encoding") };
   if (canonical) {
-    const pending2 = [(async function* () {
-      yield rootReference;
-    })()];
-    while (pending2.length) {
-      const next = await pending2.at(-1).next();
-      if (next.done) {
-        pending2.pop();
-        continue;
+    async function* descendants() {
+      if (stored) {
+        for await (const entry of stored.walk(stored.root)) if (!entry.closing) yield entry.reference;
+      } else {
+        const pending2 = [(async function* () {
+          yield rootReference;
+        })()];
+        while (pending2.length) {
+          const next = await pending2.at(-1).next();
+          if (next.done) {
+            pending2.pop();
+            continue;
+          }
+          yield next.value;
+          pending2.push(children(next.value));
+        }
       }
-      const element = await load(next.value);
+    }
+    for await (const reference of descendants()) {
+      const element = await load(reference);
       if (element.kind !== "element") continue;
       {
         const p = budget.tick();
@@ -128,7 +200,6 @@ async function* serializeDocument(source, mode, budget, format = mode === "forma
         }
         if (!absolute) throw new XmlQueryError("Failed to canonicalize: relative namespace URI", 6);
       }
-      pending2.push(children(next.value));
     }
   } else yield declaration(documentDeclaration);
   const namespaces = /* @__PURE__ */ new Map([["xml", xml]]);
@@ -196,18 +267,29 @@ async function* serializeDocument(source, mode, budget, format = mode === "forma
       await iterator.return(void 0);
     }
   }
-  const pending = [documentFrames()];
-  while (pending.length) {
+  const pending = [];
+  const frames = stored ? new StoredFrames(stored) : void 0;
+  async function push(source2) {
+    if (frames) await frames.push(source2);
+    else pending.push(source2[Symbol.asyncIterator]());
+  }
+  await push(documentFrames());
+  while (true) {
     {
       const p = budget.tick();
       if (p) await p;
     }
-    const next = await pending.at(-1).next();
-    if (next.done) {
-      pending.pop();
-      continue;
+    let frame;
+    if (frames) frame = await frames.pop();
+    else while (pending.length) {
+      const next = await pending.at(-1).next();
+      if (next.done) pending.pop();
+      else {
+        frame = next.value;
+        break;
+      }
     }
-    const frame = next.value;
+    if (!frame) break;
     if (typeof frame.content === "string") {
       yield frame.content;
       continue;
@@ -259,17 +341,21 @@ async function* serializeDocument(source, mode, budget, format = mode === "forma
       }
       yield ">";
       const indent = !canonical && format && !frame.inline && !mixed && count > 0;
-      const childNamespaces = new Map(frame.namespaces);
-      if (canonical) for (const attribute of ordered) {
-        if (attribute.namespace === xmlns) childNamespaces.set(attribute.localName, attribute.value);
+      let childNamespaces = frame.namespaces;
+      if (canonical && ordered.some((attribute) => attribute.namespace === xmlns)) {
+        const changed = new Map(frame.namespaces);
+        for (const attribute of ordered) if (attribute.namespace === xmlns) changed.set(attribute.localName, attribute.value);
+        childNamespaces = changed;
       }
       const childFrame = { depth: frame.depth + 1, namespaces: childNamespaces, preserveSpace, preserveBlanks, inline: frame.inline || mixed };
-      pending.push((async function* () {
+      const parentFrame = frame;
+      await push((async function* () {
         for await (const child of selectedChildren(reference, preserveSpace, preserveBlanks)) {
-          if (indent) yield { ...childFrame, content: "\n" + "  ".repeat(childFrame.depth) };
+          if (indent) for (const part of indentation(childFrame.depth)) yield { ...childFrame, content: part };
           yield { ...childFrame, content: child.reference };
         }
-        yield { ...frame, content: `${indent ? "\n" + "  ".repeat(frame.depth) : ""}</${current.name}>` };
+        if (indent) for (const part of indentation(parentFrame.depth)) yield { ...parentFrame, content: part };
+        yield { ...parentFrame, content: `</${current.name}>` };
       })());
     } else if (current.kind === "text" || current.kind === "cdata" && canonical) {
       for await (const part of typeof reference === "number" ? stored.text(reference) : [current.text])