@poe-platform/safe-bash 0.1.812 → 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

@@ -8,5 +8,5 @@ export declare function encryptedBiffPropertyStream(streams: ReadonlyMap<string,
  * 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 and descriptor bytes directly into caller storage.
- * Parsed descriptors and names remain resident; plaintext transfers are bounded. */
+ * 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";
@@ -107,11 +108,25 @@ export function decryptBiffPropertyContainer(encrypted, keyStream, context, char
         const source = new Binary(encrypted), { offset, size } = propertyTableRange(decrypt(source.slice(0, 8), 0), source);
         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)
-            step = reader.next(table.slice(step.value.at, step.value.size));
+        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 descriptors = step.value;
+        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;
@@ -137,7 +152,6 @@ function* readEncryptedPropertyDescriptors(source, offset, size, context, charge
         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();
         const entry = new Binary(yield { at, size: 18 });
@@ -163,29 +177,32 @@ function* readEncryptedPropertyDescriptors(source, offset, size, context, charge
         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");
     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 and descriptor bytes directly into caller storage.
- * Parsed descriptors and names remain resident; plaintext transfers are bounded. */
+ * 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"); };
@@ -193,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)
@@ -242,10 +259,19 @@ export async function decryptBiffPropertySources(encrypted, createCipher, contex
         };
         const { offset, size } = propertyTableRange(await decrypt(0, 8), input);
         const table = await stagePropertyBytes({ length: size, chunks: () => chunks(offset, size, 0) }, context, context.limits.inputBytes);
-        const reader = readEncryptedPropertyDescriptors(input, offset, size, context, charge);
-        let step = reader.next();
+        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();
@@ -267,12 +293,15 @@ export async function decryptBiffPropertySources(encrypted, createCipher, contex
         }
         await table.close();
         check();
-        const descriptors = step.value;
-        for (const entry of descriptors) {
+        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-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>>;