@poe-platform/safe-bash 0.1.812 → 0.1.814

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

@@ -396,30 +396,12 @@ export async function writeBiffProperties(book, context, staged = false) {
                     yield* propertyChunks(encoded.get(guid));
             } });
     }
-    // Opaque snapshot merging still needs random byte-array access. Keep it explicit
-    // until that reader and its codepage/identity logic migrate to retained ranges.
     const snapshots = (book.unsupportedRecords ?? []).some(record => record.source === "biff" && record.kind === "ole-properties" && record.disposition === "retained");
-    const streams = new Map();
-    if (!staged || snapshots)
-        for (const [name, value] of planned) {
-            const bytes = new Uint8Array(value.length);
-            let at = 0;
-            for (const part of propertyChunks(value)) {
-                bytes.set(part, at);
-                at += part.length;
-            }
-            streams.set(name, bytes);
-        }
-    const preserved = await mergeBiffProperties(book, streams, handledMetadata, context, charge, allocate);
-    for (const key of unsupportedKeys)
-        if (!preserved.has(key))
-            await context.diagnostic?.({ code: "biff-loss-warning", severity: "warning", message: `Unsupported Excel BIFF document property: ${key}` });
-    if (!staged)
-        return { streams, handledMetadata, async close() { } };
+    const streams = new Map(), inputs = [];
     const sources = new Map();
     const close = async () => {
         const errors = [];
-        for (const source of sources.values())
+        for (const source of [...sources.values(), ...inputs])
             try {
                 await source.close();
             }
@@ -432,8 +414,42 @@ export async function writeBiffProperties(book, context, staged = false) {
             throw new AggregateError(errors, "BIFF property sources cleanup failed");
     };
     try {
+        if (!staged || snapshots)
+            for (const [name, value] of planned) {
+                if (staged) {
+                    const source = await stagePropertyBytes(value, context);
+                    inputs.push(source);
+                    streams.set(name, source);
+                }
+                else {
+                    const bytes = new Uint8Array(value.length);
+                    let at = 0;
+                    for (const part of propertyChunks(value)) {
+                        bytes.set(part, at);
+                        at += part.length;
+                    }
+                    streams.set(name, bytes);
+                }
+            }
+        const preserved = await mergeBiffProperties(book, streams, handledMetadata, context, charge, allocate, staged ? { sources, reserve } : undefined);
+        for (const key of unsupportedKeys)
+            if (!preserved.has(key))
+                await context.diagnostic?.({ code: "biff-loss-warning", severity: "warning", message: `Unsupported Excel BIFF document property: ${key}` });
+        if (!staged)
+            return { streams, handledMetadata, async close() { } };
         for (const [name, value] of snapshots ? streams : planned)
-            sources.set(name, await stagePropertyBytes(value, context));
+            if (!sources.has(name)) {
+                const bytes = 'size' in value ? { length: value.size, async *chunks() {
+                        for (let at = 0; at < value.size;) {
+                            const part = await value.read(at, Math.min(16384, value.size - at));
+                            at += part.length;
+                            yield part;
+                        }
+                    } } : value;
+                sources.set(name, await stagePropertyBytes(bytes, context));
+            }
+        for (const input of inputs)
+            await input.close();
         return { streams: sources, handledMetadata, close };
     }
     catch (error) {
@@ -446,8 +462,9 @@ export async function writeBiffProperties(book, context, staged = false) {
         throw error;
     }
     finally {
-        if (snapshots)
+        if (staged && snapshots)
             for (const bytes of streams.values())
-                bytes.fill(0);
+                if (bytes instanceof Uint8Array)
+                    bytes.fill(0);
     }
 }

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

@@ -1,8 +1,8 @@
+import { visitBiffPropertyDictionary } from './biff-property-dictionary.js';
 import { SsconvertError } from "../spreadsheet-engine/contracts.js";
 import { invalidBiff } from "./biff-binary.js";
-import { propertyRange, readPropertySectionRanges, readPropertyValueRanges } from "./biff-property-range.js";
-import { biffDbcsTables } from "../spreadsheet-engine/encoding/biff-dbcs-tables.js";
-import { biffDecode } from "./biff-strings.js";
+import { propertyRange, readPropertySectionRanges, withPropertyValueRanges } from "./biff-property-range.js";
+import { readBiffPropertyText } from "./biff-property-text.js";
 // OLE property-set layout and IDs: LibreOffice oleprops.cxx/.hxx at
 // bce0998afefdbc355585ca324285661a2170ba77; source receipts are in the gap ledger.
 export const biffPropertyFormats = { summary: "e0859ff2f94f6810ab9108002b27b3d9",
@@ -29,70 +29,6 @@ export async function readBiffProperties(streams, context, accountText, accountW
         if (nodes > (context.limits.workbookNodes ?? context.limits.inputBytes))
             throw new SsconvertError("resource-limit", "ssconvert BIFF property node limit exceeded");
     };
-    const text = async (data, offset, codepage) => {
-        const count = await data.u32(offset), width = codepage === 1200 ? 2 : 1, size = count * width;
-        if (!count)
-            invalidBiff("empty property string buffer");
-        data.check(offset + 4, size);
-        // Admit the maximum UTF-8 expansion before allocating a decoded string.
-        if ((count - 1) * 3 > (context.limits.workbookTextBytes ?? context.limits.inputBytes))
-            throw new SsconvertError("resource-limit", "ssconvert BIFF property text limit exceeded");
-        accountWork(size);
-        const end = offset + 4 + size;
-        if ((await data.read(end - width, width)).some(Boolean))
-            invalidBiff("unterminated property string");
-        let value = "";
-        const unicode = codepage === 1200 || codepage === 65001;
-        const decoder = unicode ? new TextDecoder(codepage === 1200 ? "utf-16le" : "utf-8", { fatal: true, ignoreBOM: true }) : undefined;
-        const multibyte = biffDbcsTables[codepage];
-        let lead;
-        if (!unicode && !multibyte)
-            biffDecode(new Uint8Array(), codepage);
-        for (let at = offset + 4; at < end - width;) {
-            const bytes = await data.read(at, Math.min(16384, end - width - at));
-            at += bytes.length;
-            if (decoder) {
-                try {
-                    value += decoder.decode(bytes, { stream: true });
-                }
-                catch {
-                    invalidBiff("invalid property string encoding");
-                }
-            }
-            else if (multibyte) {
-                const characters = [];
-                for (const byte of bytes) {
-                    if (lead !== undefined) {
-                        const character = multibyte.double[lead]?.[byte];
-                        if (character === undefined || character === "\uffff")
-                            invalidBiff("invalid or truncated DBCS character");
-                        characters.push(character);
-                        lead = undefined;
-                    }
-                    else {
-                        const character = multibyte.single[byte];
-                        if (character === "\uffff")
-                            lead = byte;
-                        else
-                            characters.push(character);
-                    }
-                }
-                value += characters.join("");
-            }
-            else
-                value += biffDecode(bytes, codepage);
-        }
-        if (lead !== undefined)
-            invalidBiff("invalid or truncated DBCS character");
-        if (decoder)
-            try {
-                value += decoder.decode();
-            }
-            catch {
-                invalidBiff("invalid property string encoding");
-            }
-        return { value: accountText(value), end: width === 2 ? Math.ceil(end / 4) * 4 : end };
-    };
     for (const target of ["\u0005SummaryInformation", "\u0005DocumentSummaryInformation"]) {
         let streamName = target, bytes = streams.get(target);
         if (!bytes)
@@ -108,125 +44,109 @@ export async function readBiffProperties(streams, context, accountText, accountW
             continue;
         const file = propertyRange(bytes, context);
         accountWork(file.size);
-        const sections = await readPropertySectionRanges(file, admit, accountWork);
+        const sections = readPropertySectionRanges(file, admit, accountWork, context);
         let unknown = false;
         const modeled = [];
-        for (const { guid, offset, end } of sections) {
+        for await (const { guid, offset, end } of sections) {
             if (!biffPropertyFields.has(guid) && guid !== custom) {
                 unknown = true;
                 continue;
             }
-            const values = await readPropertyValueRanges(file.slice(offset, end - offset), admit, accountWork);
-            const cp = values.get(1);
-            let codepage = 1252;
-            if (cp) {
-                if ((await cp.u32(0)) !== 2)
-                    invalidBiff("invalid property codepage type");
-                codepage = await cp.u16(4);
-            }
-            const names = new Map(), dictionary = values.get(0);
-            try {
-                if (dictionary && guid === custom) {
-                    const length = await dictionary.u32(0);
-                    dictionary.check(4, length * 9);
-                    admit(length);
-                    let at = 4;
-                    for (let i = 0; i < length; i++) {
-                        const id = await dictionary.u32(at), entry = await text(dictionary, at + 4, codepage);
-                        if (id < 2 || names.has(id) || !entry.value)
-                            invalidBiff("invalid property dictionary entry");
-                        names.set(id, entry.value);
-                        at = entry.end;
-                    }
+            await withPropertyValueRanges(file.slice(offset, end - offset), admit, accountWork, context, async (values) => {
+                const cp = await values.get(1);
+                let codepage = 1252;
+                if (cp) {
+                    if ((await cp.u32(0)) !== 2)
+                        invalidBiff("invalid property codepage type");
+                    codepage = await cp.u16(4);
                 }
-            }
-            catch (error) {
-                if (!(error instanceof SsconvertError) || error.code !== "unsupported-feature")
-                    throw error;
-                unknown = true;
-                continue;
-            }
-            for (const [id, data] of values) {
-                context.signal.throwIfAborted();
-                if (id < 2)
-                    continue;
-                const key = guid === custom ? names.get(id) : biffPropertyFields.get(guid)?.get(id);
-                if (key === undefined || Object.hasOwn(properties, key)) {
-                    unknown = true;
-                    continue;
-                }
-                let value;
-                const type = await data.u32(0);
-                try {
-                    if (type === 30 || type === 31)
-                        value = (await text(data, 4, type === 31 ? 1200 : codepage)).value;
-                    else if (type === 3)
-                        value = (await data.u32(4)) | 0;
-                    else if (type === 5) {
-                        value = await data.f64(4);
-                        if (!Number.isFinite(value))
-                            invalidBiff("nonfinite property value");
-                    }
-                    else if (type === 11)
-                        value = (await data.u16(4)) !== 0;
-                    else if (type === 64) {
-                        const ticks = BigInt(await data.u32(4)) + (BigInt(await data.u32(8)) << 32n);
-                        if (guid === summary && id === 10) {
-                            const fraction = (ticks % 10000000n).toString().padStart(7, "0");
-                            let end = fraction.length;
-                            while (end && fraction[end - 1] === "0")
-                                end--;
-                            value = `PT${ticks / 600000000n}M${ticks / 10000000n % 60n}${end ? "." + fraction.slice(0, end) : ""}S`;
+                const dictionary = guid === custom ? await values.get(0) : undefined;
+                const supported = await visitBiffPropertyDictionary(dictionary, codepage, context, admit, accountText, accountWork, async (getName) => {
+                    for await (const [id, data] of values.entries()) {
+                        context.signal.throwIfAborted();
+                        if (id < 2)
+                            continue;
+                        const key = guid === custom ? await getName(id) : biffPropertyFields.get(guid)?.get(id);
+                        if (key === undefined || Object.hasOwn(properties, key)) {
+                            unknown = true;
+                            continue;
                         }
-                        else {
-                            value = new Date(Number(ticks / 10000n) - 11644473600000).toISOString();
-                            // The workbook model stores timestamps as strings; retain the
-                            // original property bytes when Date's millisecond precision loses ticks.
-                            if (ticks % 10000n)
-                                unknown = true;
+                        let value;
+                        const type = await data.u32(0);
+                        try {
+                            if (type === 30 || type === 31)
+                                value = (await readBiffPropertyText(data, 4, type === 31 ? 1200 : codepage, context, accountText, accountWork)).value;
+                            else if (type === 3)
+                                value = (await data.u32(4)) | 0;
+                            else if (type === 5) {
+                                value = await data.f64(4);
+                                if (!Number.isFinite(value))
+                                    invalidBiff("nonfinite property value");
+                            }
+                            else if (type === 11)
+                                value = (await data.u16(4)) !== 0;
+                            else if (type === 64) {
+                                const ticks = BigInt(await data.u32(4)) + (BigInt(await data.u32(8)) << 32n);
+                                if (guid === summary && id === 10) {
+                                    const fraction = (ticks % 10000000n).toString().padStart(7, "0");
+                                    let end = fraction.length;
+                                    while (end && fraction[end - 1] === "0")
+                                        end--;
+                                    value = `PT${ticks / 600000000n}M${ticks / 10000000n % 60n}${end ? "." + fraction.slice(0, end) : ""}S`;
+                                }
+                                else {
+                                    value = new Date(Number(ticks / 10000n) - 11644473600000).toISOString();
+                                    // The workbook model stores timestamps as strings; retain the
+                                    // original property bytes when Date's millisecond precision loses ticks.
+                                    if (ticks % 10000n)
+                                        unknown = true;
+                                }
+                                accountText(value);
+                            }
+                            else if (type === 7) {
+                                const days = await data.f64(4);
+                                if (!Number.isFinite(days) || days <= -657435 || days >= 2958466)
+                                    invalidBiff("invalid OLE property date");
+                                // OLE Automation uses 1899-12-30 and the absolute fractional day.
+                                // LibreOffice's oleprops DATE path truncates it and uses 1899-12-31;
+                                // the documented Automation representation governs the stored value.
+                                value = new Date(-2209161600000 + Math.round((Math.trunc(days) + Math.abs(days % 1)) * 86400000)).toISOString();
+                                accountText(value);
+                            }
                         }
-                        accountText(value);
-                    }
-                    else if (type === 7) {
-                        const days = await data.f64(4);
-                        if (!Number.isFinite(days) || days <= -657435 || days >= 2958466)
-                            invalidBiff("invalid OLE property date");
-                        // OLE Automation uses 1899-12-30 and the absolute fractional day.
-                        // LibreOffice's oleprops DATE path truncates it and uses 1899-12-31;
-                        // the documented Automation representation governs the stored value.
-                        value = new Date(-2209161600000 + Math.round((Math.trunc(days) + Math.abs(days % 1)) * 86400000)).toISOString();
-                        accountText(value);
+                        catch (error) {
+                            if (!(error instanceof SsconvertError) || error.code !== "unsupported-feature")
+                                throw error;
+                        }
+                        if (value === undefined) {
+                            unknown = true;
+                            continue;
+                        }
+                        if (guid === summary && id === 5 && typeof value === "string") {
+                            let count = 1;
+                            for (const character of value)
+                                if (character === ",")
+                                    count++;
+                            admit(count);
+                            accountWork(value.length);
+                            value = value.split(",").map(keyword => {
+                                let start = 0, end = keyword.length;
+                                while (start < end && isBiffKeywordSpace(keyword.charCodeAt(start)))
+                                    start++;
+                                while (end > start && isBiffKeywordSpace(keyword.charCodeAt(end - 1)))
+                                    end--;
+                                return keyword.slice(start, end);
+                            }).filter(Boolean);
+                        }
+                        accountText(key);
+                        properties[key] = value;
+                        modeled.push([offset, id, key]);
+                        observe?.({ stream: streamName, section: offset, id, key, value });
                     }
-                }
-                catch (error) {
-                    if (!(error instanceof SsconvertError) || error.code !== "unsupported-feature")
-                        throw error;
-                }
-                if (value === undefined) {
+                });
+                if (!supported)
                     unknown = true;
-                    continue;
-                }
-                if (guid === summary && id === 5 && typeof value === "string") {
-                    let count = 1;
-                    for (const character of value)
-                        if (character === ",")
-                            count++;
-                    admit(count);
-                    accountWork(value.length);
-                    value = value.split(",").map(keyword => {
-                        let start = 0, end = keyword.length;
-                        while (start < end && isBiffKeywordSpace(keyword.charCodeAt(start)))
-                            start++;
-                        while (end > start && isBiffKeywordSpace(keyword.charCodeAt(end - 1)))
-                            end--;
-                        return keyword.slice(start, end);
-                    }).filter(Boolean);
-                }
-                accountText(key);
-                properties[key] = value;
-                modeled.push([offset, id, key]);
-                observe?.({ stream: streamName, section: offset, id, key, value });
-            }
+            });
         }
         if (unknown && retained) {
             if (file.size * 2 > (context.limits.workbookTextBytes ?? context.limits.inputBytes * 2))

package/dist/spreadsheet-format-xls/biff-property-dictionary.d.ts

@@ -0,0 +1,5 @@
+import { type CapabilityContext } from "../spreadsheet-engine/contracts.js";
+import { type BiffPropertyRange } from './biff-property-range.js';
+/** Validate/account names once, retain only coordinates, and decode on lookup.
+ * Unsupported dictionary codepages skip the visitor so the caller retains the section. */
+export declare function visitBiffPropertyDictionary(data: BiffPropertyRange | undefined, codepage: number, context: CapabilityContext, admit: (count: number) => void, accountText: (text: string) => string, accountWork: (amount: number) => void, visit: (get: (id: number) => Promise<string | undefined>) => Promise<void>): Promise<boolean>;

package/dist/spreadsheet-format-xls/biff-property-dictionary.js

@@ -0,0 +1,75 @@
+import { IntegerTable } from "@poe-platform/safe-fs/storage";
+import { SsconvertError } from "../spreadsheet-engine/contracts.js";
+import { invalidBiff } from './biff-binary.js';
+import { propertyIndexStorage } from './biff-property-range.js';
+import { readBiffPropertyText } from './biff-property-text.js';
+/** Validate/account names once, retain only coordinates, and decode on lookup.
+ * Unsupported dictionary codepages skip the visitor so the caller retains the section. */
+export async function visitBiffPropertyDictionary(data, codepage, context, admit, accountText, accountWork, visit) {
+    const count = data ? await data.u32(0) : 0;
+    if (data) {
+        data.check(4, count * 9);
+        admit(count);
+    }
+    const storage = data && context.createWorkingStorage?.();
+    let active = true, supported = true;
+    const check = () => {
+        context.signal.throwIfAborted();
+        data?.check(0, 0);
+        if (!active)
+            throw new SsconvertError('invalid-request', 'BIFF property dictionary index is closed');
+    };
+    try {
+        const backing = storage && propertyIndexStorage(storage, data);
+        backing?.allocate(8);
+        const index = backing ? new IntegerTable(backing, 64) : new Map();
+        let at = 4;
+        for (let i = 0; i < count; i++) {
+            const id = await data.u32(at);
+            let entry;
+            try {
+                entry = await readBiffPropertyText(data, at + 4, codepage, context, accountText, accountWork);
+            }
+            catch (error) {
+                if (!(error instanceof SsconvertError) || error.code !== 'unsupported-feature')
+                    throw error;
+                supported = false;
+                break;
+            }
+            if (id < 2 || await index.get(BigInt(id)) !== undefined || !entry.value)
+                invalidBiff('invalid property dictionary entry');
+            check();
+            await index.set(BigInt(id), BigInt(at + 4));
+            check();
+            at = entry.end;
+        }
+        if (supported)
+            await visit(async (id) => {
+                check();
+                const position = await index.get(BigInt(id));
+                check();
+                if (position === undefined)
+                    return undefined;
+                const entry = await readBiffPropertyText(data, Number(position), codepage, context, text => text, accountWork);
+                check();
+                return entry.value;
+            });
+        check();
+    }
+    catch (error) {
+        try {
+            await storage?.close();
+        }
+        catch (cleanup) {
+            throw new AggregateError([error, cleanup], 'BIFF property dictionary and cleanup failed');
+        }
+        throw error;
+    }
+    finally {
+        active = false;
+    }
+    await storage?.close();
+    context.signal.throwIfAborted();
+    data?.check(0, 0);
+    return supported;
+}

package/dist/spreadsheet-format-xls/biff-property-index.d.ts

@@ -0,0 +1,23 @@
+import type { WorkingStorage } from "../spreadsheet-engine/contracts.js";
+export interface BiffPropertyDescriptor {
+    offset: number;
+    size: number;
+    block: number;
+    name: string;
+}
+/** Two bounded radix caches index UTF-16 name edges and stable range order.
+ * Linked fixed-size records replay original descriptor order without an array. */
+export declare class BiffPropertyDescriptorIndex {
+    private readonly storage;
+    private readonly check;
+    private readonly names;
+    private readonly ranges;
+    private node;
+    private count;
+    private first;
+    private last;
+    constructor(storage: WorkingStorage, check: () => void);
+    add(entry: BiffPropertyDescriptor): Promise<void>;
+    validate(): Promise<void>;
+    entries(): AsyncIterable<BiffPropertyDescriptor>;
+}

package/dist/spreadsheet-format-xls/biff-property-index.js

@@ -0,0 +1,93 @@
+import { IntegerTable } from "@poe-platform/safe-fs/storage";
+import { Binary, invalidBiff } from './biff-binary.js';
+/** Two bounded radix caches index UTF-16 name edges and stable range order.
+ * Linked fixed-size records replay original descriptor order without an array. */
+export class BiffPropertyDescriptorIndex {
+    storage;
+    check;
+    names;
+    ranges;
+    node = 2n;
+    count = 0;
+    first = 0;
+    last = 0;
+    constructor(storage, check) {
+        this.storage = storage;
+        this.check = check;
+        storage.allocate(8);
+        this.check();
+        this.names = new IntegerTable(storage, 64);
+        this.ranges = new IntegerTable(storage, 64);
+    }
+    async add(entry) {
+        this.check();
+        let node = 1n;
+        const name = entry.name.toUpperCase();
+        for (let i = 0; i < name.length; i++) {
+            const key = node << 16n | BigInt(name.charCodeAt(i));
+            let next = await this.names.get(key);
+            this.check();
+            if (next === undefined) {
+                next = this.node++;
+                await this.names.set(key, next);
+                this.check();
+            }
+            node = next;
+        }
+        const terminal = node << 16n;
+        if (await this.names.get(terminal) !== undefined)
+            invalidBiff('duplicate or invalid encrypted property stream name');
+        this.check();
+        await this.names.set(terminal, 1n);
+        this.check();
+        await this.ranges.set(BigInt(entry.offset) << 32n | BigInt(this.count++), BigInt(entry.offset + entry.size));
+        this.check();
+        const bytes = new Uint8Array(88), view = new DataView(bytes.buffer);
+        view.setUint32(8, entry.offset, true);
+        view.setUint32(12, entry.size, true);
+        view.setUint16(16, entry.block, true);
+        view.setUint16(18, entry.name.length, true);
+        for (let i = 0; i < entry.name.length; i++)
+            view.setUint16(20 + i * 2, entry.name.charCodeAt(i), true);
+        const position = this.storage.allocate(bytes.length);
+        this.check();
+        try {
+            await this.storage.write(position, bytes);
+            this.check();
+            if (this.last) {
+                view.setFloat64(0, position, true);
+                await this.storage.write(this.last, bytes.subarray(0, 8));
+                this.check();
+            }
+            else
+                this.first = position;
+            this.last = position;
+        }
+        finally {
+            bytes.fill(0);
+        }
+    }
+    async validate() {
+        let end = 0n;
+        for await (const [key, next] of this.ranges.entries()) {
+            this.check();
+            if (key >> 32n < end)
+                invalidBiff('overlapping encrypted property payloads');
+            end = next;
+        }
+    }
+    async *entries() {
+        let position = this.first;
+        while (position) {
+            this.check();
+            const bytes = new Binary(await this.storage.read(position, 88));
+            this.check();
+            bytes.check(0, 88);
+            position = bytes.f64(0);
+            let name = '';
+            for (let i = 0; i < bytes.u16(18); i++)
+                name += String.fromCharCode(bytes.u16(20 + i * 2));
+            yield { offset: bytes.u32(8), size: bytes.u32(12), block: bytes.u16(16), name };
+        }
+    }
+}

package/dist/spreadsheet-format-xls/biff-property-name.d.ts

@@ -0,0 +1,4 @@
+import { type CapabilityContext } from "../spreadsheet-engine/contracts.js";
+import type { BiffPropertyBytes } from './biff-property-bytes.js';
+/** Validate representability before exposing bounded encoded windows. */
+export declare function createBiffPropertyNameEncoder(context: CapabilityContext, charge: (amount: number) => void, accountText: (text: string) => string): (name: string, codepage: number) => BiffPropertyBytes | undefined;