@poe-platform/safe-bash 0.1.811 → 0.1.813

package/dist/safe-bash-xml-engine/stored-document.d.ts

@@ -18,7 +18,7 @@ export declare class StoredXmlDocument {
     get document(): number;
     static parse(source: AsyncIterable<string> | Iterable<string>, context: PagedStorageContext & {
         readonly registerCleanup?: (cleanup: () => Promise<void>) => void;
-    }, budget: XmlBudget, pages?: number): Promise<StoredXmlDocument>;
+    }, budget: XmlBudget, pages?: number, recover?: (message: string) => void): Promise<StoredXmlDocument>;
     private field;
     private set;
     private append;

package/dist/safe-bash-xml-engine/stored-document.js

@@ -1,6 +1,6 @@
 import {
   StoredXmlDocument
-} from "../safe-bash/command-chunks/chunk-D2KZ66W4.js";
+} from "../safe-bash/command-chunks/chunk-RLCQ7BN3.js";
 import "../safe-bash/command-chunks/chunk-65DS4IOB.js";
 export {
   StoredXmlDocument

package/dist/safe-bash-xml-engine/stored-evaluate.js

@@ -3,7 +3,7 @@ import {
   expressionText,
   formatScalar,
   testPredicate
-} from "../safe-bash/command-chunks/chunk-JYUJAF4L.js";
+} from "../safe-bash/command-chunks/chunk-G7NENPYV.js";
 import {
   XmlQueryError
 } from "../safe-bash/command-chunks/chunk-3I5WTVWZ.js";

package/dist/spreadsheet-engine/formulas/functions/python-printf.js

@@ -1,5 +1,6 @@
 import { SsconvertError } from "../../contracts.js";
 import { boundedText } from "./common.js";
+import { rendered } from "../values.js";
 import { nonPrintable } from "./python-printf-profile.js";
 import { inUnicodeRanges } from "./python-unicode-profile.js";
 class PythonFormatError extends Error {
@@ -20,49 +21,66 @@ function floatText(value) {
     const text = String(value);
     return text.includes(".") ? text : text + ".0";
 }
-function pythonText(profile, value, repr, ascii, host, precision) {
+function* pythonText(profile, value, repr, ascii, host) {
     host.tick();
-    if (value === null)
-        return "None";
-    if (typeof value === "number")
-        return floatText(value);
-    if (typeof value === "boolean")
-        return value ? "True" : "False";
+    if (value === null) {
+        yield* "None";
+        return;
+    }
+    if (typeof value === "number") {
+        yield* floatText(value);
+        return;
+    }
+    if (typeof value === "boolean") {
+        yield* value ? "True" : "False";
+        return;
+    }
     if (typeof value === "object") {
         if ("range" in value) {
-            // The native default repr includes an address. Precision can exclude
-            // every address digit while retaining a portable, source-defined prefix.
-            const prefix = "<RangeRef object at 0x";
-            if (precision !== undefined && precision <= prefix.length)
-                return prefix.slice(0, precision);
+            // Precision may stop before the address, whose native bytes are unstable.
+            yield* "<RangeRef object at 0x";
             throw new SsconvertError("unsupported-feature", "Unsupported ssconvert feature: Python RangeRef object representation");
         }
-        return "[" + value.columns.map(column => "[" + column.map(cell => pythonText(profile, cell, true, ascii, host)).join(", ") + "]").join(", ") + "]";
+        yield "[";
+        for (let column = 0; column < value.columns.length; column++) {
+            if (column)
+                yield* ", ";
+            yield "[";
+            const cells = value.columns[column];
+            for (let row = 0; row < cells.length; row++) {
+                if (row)
+                    yield* ", ";
+                yield* pythonText(profile, cells[row], true, ascii, host);
+            }
+            yield "]";
+        }
+        yield "]";
+        return;
+    }
+    if (!repr) {
+        yield* value;
+        return;
     }
-    if (!repr)
-        return value;
     const quote = value.includes("'") && !value.includes('"') ? '"' : "'";
-    let result = quote;
+    yield quote;
     for (const char of value) {
         host.tick();
         const code = char.codePointAt(0);
         if (char === quote || char === "\\")
-            result += "\\" + char;
+            yield* "\\" + char;
         else if (char === "\n")
-            result += "\\n";
+            yield* "\\n";
         else if (char === "\r")
-            result += "\\r";
+            yield* "\\r";
         else if (char === "\t")
-            result += "\\t";
+            yield* "\\t";
         else if (ascii && code > 127 || inUnicodeRanges(code, nonPrintable) || inUnicodeRanges(code, profile.nonPrintable))
-            result += code <= 255 ? "\\x" + code.toString(16).padStart(2, "0") : code <= 65535 ?
+            yield* code <= 255 ? "\\x" + code.toString(16).padStart(2, "0") : code <= 65535 ?
                 "\\u" + code.toString(16).padStart(4, "0") : "\\U" + code.toString(16).padStart(8, "0");
         else
-            result += char;
-        if (result.length > host.context.limits.outputBytes)
-            throw new SsconvertError("resource-limit", "ssconvert calculation text limit exceeded");
+            yield char;
     }
-    return result + quote;
+    yield quote;
 }
 function pythonValue(value, host, argument = true) {
     host.tick();
@@ -81,7 +99,7 @@ function pythonValue(value, host, argument = true) {
         return { columns: Array.from({ length: rows[0]?.length ?? 0 }, (_, column) => rows.map(row => pythonValue(row[column], host, false))) };
     }
     // Both Python C-string acquisition and returned Gnumeric strings stop at NUL.
-    return typeof value.value === "string" ? value.value.split("\0", 1)[0] : value.value;
+    return typeof value.value === "string" ? rendered(value).split("\0", 1)[0] : value.value;
 }
 function decimalRatio(value) {
     const view = new DataView(new ArrayBuffer(8));
@@ -234,16 +252,21 @@ export function pythonPrintf(profile, args, host) {
             const value = take();
             let text, sign = "", prefix = "", numeric = false;
             if ("sra".includes(conversion)) {
-                text = pythonText(profile, value, conversion !== "s", conversion === "a", host, precision);
-                if (precision !== undefined) {
-                    let count = 0, truncated = "";
-                    for (const char of text) {
+                const representation = pythonText(profile, value, conversion !== "s", conversion === "a", host);
+                text = "";
+                try {
+                    for (let count = 0; precision === undefined || count < precision; count++) {
                         host.tick();
-                        if (count++ >= precision)
+                        const next = representation.next();
+                        if (next.done)
                             break;
-                        truncated += char;
+                        text += next.value;
+                        if (text.length > limit)
+                            throw new SsconvertError("resource-limit", "ssconvert calculation text limit exceeded");
                     }
-                    text = truncated;
+                }
+                finally {
+                    representation.return(undefined);
                 }
             }
             else if (conversion === "c") {

package/dist/spreadsheet-format-xls/biff-encrypted-properties.d.ts

@@ -7,6 +7,6 @@ export declare function encryptedBiffPropertyStream(streams: ReadonlyMap<string,
 /** MS-OFFCRYPTO 2.3.5.4: header/table restart block 0; each payload restarts its
  * descriptor block. These are not Workbook's absolute-position 1024-byte chunks. */
 export declare function decryptBiffPropertyContainer(encrypted: Uint8Array, keyStream: (block: number, length: number) => Uint8Array, context: CapabilityContext, charge: (amount: number) => void, createCipher?: (block: number) => BiffRc4Cipher): ReadonlyMap<string, Uint8Array>;
-/** Decrypt retained ciphertext directly into caller storage. Only the descriptor
- * table is buffered; payload plaintext never accumulates in RAM. */
+/** Decrypt retained ciphertext and descriptor bytes directly into caller storage.
+ * Parsed descriptors, duplicate names and overlap order use caller-backed indexes. */
 export declare function decryptBiffPropertySources(encrypted: Uint8Array | RangeSource, createCipher: (block: number) => BiffRc4Cipher, context: CapabilityContext, charge: (amount: number) => void): Promise<ReadonlyMap<string, BiffPropertySource>>;

package/dist/spreadsheet-format-xls/biff-encrypted-properties.js

@@ -1,3 +1,4 @@
+import { BiffPropertyDescriptorIndex } from "./biff-property-index.js";
 import { SsconvertError } from "../spreadsheet-engine/contracts.js";
 import { stagePropertyBytes } from "./biff-property-bytes.js";
 import { Binary, invalidBiff } from "./biff-binary.js";
@@ -105,7 +106,27 @@ export function decryptBiffPropertyContainer(encrypted, keyStream, context, char
         if (encrypted.length > context.limits.inputBytes)
             throw new SsconvertError("resource-limit", "ssconvert encrypted BIFF property input limit exceeded");
         const source = new Binary(encrypted), { offset, size } = propertyTableRange(decrypt(source.slice(0, 8), 0), source);
-        const descriptors = readEncryptedPropertyDescriptors(source, offset, size, decrypt(source.slice(offset, size), 0), context, charge);
+        const table = new Binary(decrypt(source.slice(offset, size), 0));
+        const reader = readEncryptedPropertyDescriptors(source, offset, size, context, charge);
+        const descriptors = [], names = new Set();
+        let step = reader.next();
+        while (!step.done) {
+            if ("entry" in step.value) {
+                const entry = step.value.entry, name = entry.name.toUpperCase();
+                if (names.has(name))
+                    invalidBiff("duplicate or invalid encrypted property stream name");
+                names.add(name);
+                descriptors.push(entry);
+                step = reader.next(new Uint8Array());
+            }
+            else
+                step = reader.next(table.slice(step.value.at, step.value.size));
+        }
+        table.bytes.fill(0);
+        const ordered = [...descriptors].sort((a, b) => a.offset - b.offset);
+        for (let i = 1; i < ordered.length; i++)
+            if (ordered[i].offset < ordered[i - 1].offset + ordered[i - 1].size)
+                invalidBiff("overlapping encrypted property payloads");
         for (const entry of descriptors)
             result.set(entry.name, decrypt(source.slice(entry.offset, entry.size), entry.block));
         return result;
@@ -123,62 +144,65 @@ function propertyTableRange(bytes, source) {
     source.check(offset, size);
     return { offset, size };
 }
-function readEncryptedPropertyDescriptors(source, offset, size, bytes, context, charge) {
-    const table = new Binary(bytes), count = table.u32(0);
+function* readEncryptedPropertyDescriptors(source, offset, size, context, charge) {
+    const count = new Binary(yield { at: 0, size: 4 }).u32(0);
     if (count > Math.floor((size - 4) / 18))
         invalidBiff("invalid encrypted property descriptor count");
     if (count > (context.limits.workbookNodes ?? context.limits.inputBytes))
         throw new SsconvertError("resource-limit", "ssconvert encrypted BIFF property node limit exceeded");
     charge(count);
     let at = 4, textBytes = 0;
-    const descriptors = [], names = new Set();
     for (let i = 0; i < count; i++) {
         context.signal.throwIfAborted();
-        table.check(at, 18);
-        const start = table.u32(at), length = table.u32(at + 4), block = table.u16(at + 8), nameLength = table.u8(at + 10), flags = table.u8(at + 11);
-        if (flags !== 1 || table.u32(at + 12) !== 0)
+        const entry = new Binary(yield { at, size: 18 });
+        entry.check(0, 18);
+        const start = entry.u32(0), length = entry.u32(4), block = entry.u16(8), nameLength = entry.u8(10), flags = entry.u8(11);
+        if (flags !== 1 || entry.u32(12) !== 0)
             invalidBiff("invalid encrypted property descriptor flags");
         at += 16;
         if (!nameLength || nameLength > 31)
             invalidBiff("invalid encrypted property stream name");
-        table.check(at, (nameLength + 1) * 2);
+        const nameBytes = new Binary(yield { at, size: (nameLength + 1) * 2 });
+        nameBytes.check(0, (nameLength + 1) * 2);
         charge(nameLength);
-        if (table.u16(at + nameLength * 2) !== 0)
+        if (nameBytes.u16(nameLength * 2) !== 0)
             invalidBiff("unterminated encrypted property stream name");
         textBytes += nameLength * 3;
         if (textBytes > (context.limits.workbookTextBytes ?? context.limits.inputBytes))
             throw new SsconvertError("resource-limit", "ssconvert encrypted BIFF property text limit exceeded");
         let name;
         try {
-            name = new TextDecoder("utf-16le", { fatal: true, ignoreBOM: true }).decode(table.slice(at, nameLength * 2));
+            name = new TextDecoder("utf-16le", { fatal: true, ignoreBOM: true }).decode(nameBytes.slice(0, nameLength * 2));
         }
         catch {
             invalidBiff("invalid encrypted property stream name");
         }
-        if (name.includes("\0") || names.has(name.toUpperCase()))
+        if (name.includes("\0"))
             invalidBiff("duplicate or invalid encrypted property stream name");
-        names.add(name.toUpperCase());
         at += (nameLength + 1) * 2;
         source.check(start, length);
         if (start < 8 || start < offset + size && start + length > offset)
             invalidBiff("overlapping encrypted property ranges");
-        descriptors.push({ offset: start, size: length, block, name });
+        yield { entry: { offset: start, size: length, block, name } };
     }
     if (at !== size)
         invalidBiff("invalid encrypted property descriptor size");
-    table.bytes.fill(0);
     charge(count * Math.ceil(Math.log2(count + 1)));
-    const ordered = [...descriptors].sort((a, b) => a.offset - b.offset);
-    for (let i = 1; i < ordered.length; i++)
-        if (ordered[i].offset < ordered[i - 1].offset + ordered[i - 1].size)
-            invalidBiff("overlapping encrypted property payloads");
-    return descriptors;
 }
-/** Decrypt retained ciphertext directly into caller storage. Only the descriptor
- * table is buffered; payload plaintext never accumulates in RAM. */
+/** Decrypt retained ciphertext and descriptor bytes directly into caller storage.
+ * Parsed descriptors, duplicate names and overlap order use caller-backed indexes. */
 export async function decryptBiffPropertySources(encrypted, createCipher, context, charge) {
     const result = new Map(), owned = [];
     const input = propertyRange(encrypted, context);
+    let indexStorage;
+    let indexClosing;
+    const retireIndex = () => {
+        if (!indexStorage)
+            return indexClosing ?? Promise.resolve();
+        const storage = indexStorage;
+        indexStorage = undefined;
+        return indexClosing = storage.close();
+    };
     let closed = false;
     const check = () => { context.signal.throwIfAborted(); if (closed)
         throw new SsconvertError("invalid-request", "Encrypted BIFF property reader disposed"); };
@@ -186,7 +210,7 @@ export async function decryptBiffPropertySources(encrypted, createCipher, contex
         closed = true;
         for (const bytes of owned)
             bytes.fill(0);
-        const outcomes = await Promise.allSettled([...result.values()].map(source => source.close()));
+        const outcomes = await Promise.allSettled([...result.values()].map(source => source.close()).concat([retireIndex()]));
         result.clear();
         const errors = outcomes.filter((value) => value.status === "rejected").map(value => value.reason);
         if (errors.length)
@@ -234,12 +258,50 @@ export async function decryptBiffPropertySources(encrypted, createCipher, contex
             return output;
         };
         const { offset, size } = propertyTableRange(await decrypt(0, 8), input);
-        const descriptors = readEncryptedPropertyDescriptors(input, offset, size, await decrypt(offset, size), context, charge);
-        for (const entry of descriptors) {
+        const table = await stagePropertyBytes({ length: size, chunks: () => chunks(offset, size, 0) }, context, context.limits.inputBytes);
+        let index;
+        try {
+            indexStorage = context.createWorkingStorage();
+            check();
+            index = new BiffPropertyDescriptorIndex(indexStorage, check);
+            const reader = readEncryptedPropertyDescriptors(input, offset, size, context, charge);
+            let step = reader.next();
+            while (!step.done) {
+                if ("entry" in step.value) {
+                    await index.add(step.value.entry);
+                    step = reader.next(new Uint8Array());
+                    continue;
+                }
+                const bytes = await table.read(step.value.at, step.value.size, { signal: context.signal });
+                try {
+                    check();
+                    step = reader.next(bytes);
+                }
+                finally {
+                    bytes.fill(0);
+                }
+            }
+        }
+        catch (error) {
+            try {
+                await table.close();
+            }
+            catch (cleanup) {
+                throw new AggregateError([error, cleanup], "Encrypted BIFF descriptor read and cleanup failed");
+            }
+            throw error;
+        }
+        await table.close();
+        check();
+        await index.validate();
+        check();
+        for await (const entry of index.entries()) {
             const source = await stagePropertyBytes({ length: entry.size, chunks: () => chunks(entry.offset, entry.size, entry.block) }, context, context.limits.inputBytes);
             result.set(entry.name, source);
             check();
         }
+        await retireIndex();
+        check();
         return result;
     }
     catch (error) {

package/dist/spreadsheet-format-xls/biff-metadata.d.ts

@@ -5,6 +5,7 @@ import { type BiffRecord } from "./biff-binary.js";
 export declare function biffNode(name: string, attributes: Readonly<Record<string, ImportedValue>>, text?: string, children?: readonly ImportedValue[]): ImportedValue;
 export declare const biffProtectionPermissions: readonly ["objects", "scenarios", "formatCells", "formatColumns", "formatRows", "insertColumns", "insertRows", "insertHyperlinks", "deleteColumns", "deleteRows", "selectLockedCells", "sort", "autoFilter", "pivotTables", "selectUnlockedCells"];
 export declare const biffMetadataOpcodes: Set<number>;
+export declare function biffHeaderParts(text: string): Readonly<Record<string, string>>;
 /** Source-backed neutral records consumed by both existing workbook writers. */
 interface BiffMetadata {
     records: UnsupportedRecord[];

package/dist/spreadsheet-format-xls/biff-metadata.js

@@ -11,7 +11,7 @@ export const biffProtectionPermissions = ["objects", "scenarios", "formatCells",
     "sort", "autoFilter", "pivotTables", "selectUnlockedCells"];
 export const biffMetadataOpcodes = new Set([0x2a, 0x2b, 0x25, 0x225, 0x81, 0x83, 0x84, 0xa1, 0x55, 0x23e, 0x3e,
     0x1d, 0x1a, 0x1b, 0x41, 0xa0, 0x867, 0x1c, 0x1b6]);
-function header(text) {
+export function biffHeaderParts(text) {
     const values = { Left: "", Middle: "", Right: "" };
     const substitutions = { P: "&[PAGE]", N: "&[PAGES]", D: "&[DATE]", T: "&[TIME]", F: "&[FILE]", A: "&[TAB]", Z: "&[PATH]" };
     let side = "Left";
@@ -234,7 +234,7 @@ function* metadataSteps(length, revision, codepage, context) {
         result.push({ source: "Gnumeric_XmlIO:sax", kind: "PrintInformation", disposition: "retained",
             data: biffNode("PrintInformation", {}, "", [biffNode("Margins", {}, "", Object.entries(margins).map(([name, Points]) => biffNode(name, { Points, PrefUnit: "mm" }))),
                 biffNode("Scale", fitToPage ? { type: "fit", cols: fitColumns, rows: fitRows } : scale), ...Object.entries(print).map(([name, value]) => biffNode(name, { value })), biffNode("order", {}, order),
-                biffNode("orientation", {}, orientation), biffNode("Header", header(headerText)), biffNode("Footer", header(footerText)),
+                biffNode("orientation", {}, orientation), biffNode("Header", biffHeaderParts(headerText)), biffNode("Footer", biffHeaderParts(footerText)),
                 biffNode("paper", {}, paper), biffNode("comments", { placement: commentPlacement }), biffNode("errors", { PrintErrorsAs: errorDisplay }), ...breaks]) });
     if (objects.length)
         result.push({ source: "Gnumeric_XmlIO:sax", kind: "Objects", disposition: "retained", data: biffNode("Objects", {}, "", objects) });

package/dist/spreadsheet-format-xls/biff-properties-merge.d.ts

@@ -1,4 +1,8 @@
-import { type CapabilityContext } from "../spreadsheet-engine/contracts.js";
+import type { BiffPropertySource } from './biff-encrypted-properties-write.js';
+import { type CapabilityContext, type RangeSource } from "../spreadsheet-engine/contracts.js";
 import type { UnsupportedRecord, Workbook } from "../spreadsheet-ast/index.js";
 /** Rebuild offsets around original opaque spans. Never transcode their codepage. */
-export declare function mergeBiffProperties(book: Workbook, streams: Map<string, Uint8Array>, handled: Set<UnsupportedRecord>, context: CapabilityContext, charge: (amount: number) => void, allocate: (length: number) => Uint8Array): Promise<ReadonlySet<string>>;
+export declare function mergeBiffProperties(book: Workbook, streams: Map<string, Uint8Array | RangeSource>, handled: Set<UnsupportedRecord>, context: CapabilityContext, charge: (amount: number) => void, allocate: (length: number) => Uint8Array, staged?: {
+    sources: Map<string, BiffPropertySource>;
+    reserve: (length: number) => number;
+}): Promise<ReadonlySet<string>>;