@poe-platform/safe-bash 0.1.814 → 0.1.816

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

@@ -1,11 +1,12 @@
+import { BiffMutablePropertyValues } from './biff-property-values.js';
 import { createBiffPropertyNameEncoder } from "./biff-property-name.js";
 import { readBiffPropertyText } from "./biff-property-text.js";
-import { stageWideBiffProperty } from './biff-property-transcode.js';
+import { wideBiffPropertyBytes } from './biff-property-transcode.js';
 import { stagePropertyBytes, propertyChunks } from './biff-property-bytes.js';
 import { SsconvertError } from "../spreadsheet-engine/contracts.js";
 import { Binary, invalidBiff } from "./biff-binary.js";
 import { biffPropertyFields, biffPropertyFormats, readBiffProperties } from "./biff-properties.js";
-import { propertyRange, readPropertySectionRanges, readPropertyValueRanges } from "./biff-property-range.js";
+import { propertyRange, readPropertySectionRanges, withPropertyValueRanges } from "./biff-property-range.js";
 /** Rebuild offsets around original opaque spans. Never transcode their codepage. */
 export async function mergeBiffProperties(book, streams, handled, context, charge, allocate, staged) {
     const canonical = (name) => ["\u0005SummaryInformation", "\u0005DocumentSummaryInformation"].find(target => target.toUpperCase() === name.toUpperCase());
@@ -89,8 +90,16 @@ export async function mergeBiffProperties(book, streams, handled, context, charg
             const file = propertyRange(input, context), sections = [];
             for await (const section of readPropertySectionRanges(file, admit, charge, context)) {
                 const bytes = file.slice(section.offset, section.end - section.offset);
-                sections.push({ ...section, bytes, ...(biffPropertyFields.has(section.guid) || section.guid === biffPropertyFormats.custom ?
-                        { values: await readPropertyValueRanges(bytes, admit, charge, context) } : {}) });
+                let values;
+                if (biffPropertyFields.has(section.guid) || section.guid === biffPropertyFormats.custom) {
+                    values = new BiffMutablePropertyValues(context, charge);
+                    temporarySources.push(values);
+                    await withPropertyValueRanges(bytes, admit, charge, context, async (source) => {
+                        for await (const [id, value] of source.entries())
+                            await values.set(id, value);
+                    });
+                }
+                sections.push({ ...section, bytes, ...(values ? { values } : {}) });
             }
             return sections;
         };
@@ -122,10 +131,10 @@ export async function mergeBiffProperties(book, streams, handled, context, charg
             }
         };
         const dictionary = async function* (section, names = true) {
-            const data = section.values?.get(0);
+            const data = await section.values?.get(0);
             if (!data)
                 return;
-            const cp = await section.values?.get(1)?.u16(4) ?? 1252, count = await data.u32(0);
+            const cp = await (await section.values?.get(1))?.u16(4) ?? 1252, count = await data.u32(0);
             data.check(4, count * 9);
             if (names) {
                 charge(data.size);
@@ -152,6 +161,12 @@ export async function mergeBiffProperties(book, streams, handled, context, charg
                 yield { id, name, bytes: data.slice(start, at - start) };
             }
         };
+        const reserve = staged?.reserve ?? ((length) => {
+            charge(length);
+            if (length > 0xffffffff || length > context.limits.outputBytes)
+                throw new SsconvertError("resource-limit", "ssconvert BIFF property output bytes limit exceeded");
+            return length;
+        });
         const writeDictionary = async (section, plan) => {
             const output = { length: plan.length, async *chunks() {
                     const header = new Uint8Array(4);
@@ -163,15 +178,13 @@ export async function mergeBiffProperties(book, streams, handled, context, charg
                             yield* chunks(entry.bytes);
                         }
                     if (plan.append) {
-                        charge(plan.append.size);
-                        yield* chunks(plan.append);
+                        charge(plan.append.length);
+                        yield* propertyChunks(plan.append);
                     }
                 } };
             if (staged) {
                 staged.reserve(plan.length);
-                const source = await stagePropertyBytes(output, context);
-                temporarySources.push(source);
-                section.values.set(0, propertyRange(source, context));
+                await section.values.set(0, { size: plan.length, chunks: output.chunks });
             }
             else {
                 const bytes = allocate(plan.length);
@@ -180,11 +193,11 @@ export async function mergeBiffProperties(book, streams, handled, context, charg
                     bytes.set(part, at);
                     at += part.length;
                 }
-                section.values.set(0, propertyRange(bytes, context));
+                await section.values.set(0, propertyRange(bytes, context));
             }
         };
         const remove = async (section, id) => {
-            section.values.delete(id);
+            await section.values.delete(id);
             if (section.guid === biffPropertyFormats.custom) {
                 let length = 4, count = 0;
                 for await (const entry of dictionary(section))
@@ -198,18 +211,16 @@ export async function mergeBiffProperties(book, streams, handled, context, charg
         const take = async (property) => {
             charge(fresh.get(property.stream).length);
             const section = fresh.get(property.stream).find(section => section.offset === property.section);
-            const value = section.values.get(property.id);
+            const value = (await section.values.get(property.id));
             await remove(section, property.id);
             pending.delete(property.key);
             return value;
         };
         const wide = async (source, section) => {
-            if (await source.u32(0) !== 30 || (await section.values.get(1)?.u16(4) ?? 1252) === 65001)
+            if (await source.u32(0) !== 30 || (await (await section.values.get(1))?.u16(4) ?? 1252) === 65001)
                 return source;
             if (staged) {
-                const output = await stageWideBiffProperty(source, context, charge, staged.reserve);
-                temporarySources.push(output);
-                return propertyRange(output, context);
+                return wideBiffPropertyBytes(source, context, charge, staged.reserve);
             }
             const data = await materialize(source);
             const value = new TextDecoder("utf-8", { fatal: true, ignoreBOM: true }).decode(data.slice(8, data.u32(4) - 1));
@@ -229,9 +240,11 @@ export async function mergeBiffProperties(book, streams, handled, context, charg
         };
         for (const [name, snapshot] of snapshots) {
             const seen = new Set();
-            let modeled = snapshot.modeled;
-            if (!modeled) {
-                modeled = [];
+            function* modeled() {
+                if (snapshot.modeled) {
+                    yield* snapshot.modeled;
+                    return;
+                }
                 // SummaryInformation is read first. A legacy document-only snapshot lacks
                 // that earlier stream's ownership decisions: infer only unchanged values.
                 for (const property of original.values()) {
@@ -241,11 +254,11 @@ export async function mergeBiffProperties(book, streams, handled, context, charg
                     if (name === "\u0005SummaryInformation" || snapshots.has("\u0005SummaryInformation") ||
                         Object.hasOwn(book.properties ?? {}, property.key) && same(property.value, book.properties?.[property.key])) {
                         admit(1);
-                        modeled.push([property.section, property.id, property.key]);
+                        yield [property.section, property.id, property.key];
                     }
                 }
             }
-            for (const entry of modeled) {
+            for (const entry of modeled()) {
                 admit(1);
                 if (!Array.isArray(entry) || entry.length !== 3 || typeof entry[0] !== "number" || typeof entry[1] !== "number" || typeof entry[2] !== "string")
                     invalidBiff("invalid retained property identity");
@@ -265,7 +278,7 @@ export async function mergeBiffProperties(book, streams, handled, context, charg
                         await take(replacement);
                 }
                 else if (replacement)
-                    section.values.set(id, await wide(await take(replacement), section));
+                    await section.values.set(id, await wide(await take(replacement), section));
             }
         }
         const encodeName = createBiffPropertyNameEncoder(context, charge, accountText);
@@ -301,13 +314,13 @@ export async function mergeBiffProperties(book, streams, handled, context, charg
                     await warn(property.key, "opaque name collision");
                     continue;
                 }
-                const cp = await values.get(1)?.u16(4) ?? 1252, text = encodeName(property.key, cp);
+                const cp = await (await values.get(1))?.u16(4) ?? 1252, text = encodeName(property.key, cp);
                 if (!text) {
                     await warn(property.key, "name cannot be encoded in the original codepage");
                     continue;
                 }
                 id = maximumId;
-                for (const key of values.keys())
+                for await (const [key] of values.entries())
                     id = Math.max(id, key);
                 id++;
                 if (id > 0xffffffff) {
@@ -324,52 +337,29 @@ export async function mergeBiffProperties(book, streams, handled, context, charg
                         if (length > size)
                             yield new Uint8Array(length - size);
                     } };
-                let bytes;
-                if (staged) {
-                    staged.reserve(length);
-                    const source = await stagePropertyBytes(entry, context);
-                    temporarySources.push(source);
-                    bytes = propertyRange(source, context);
-                }
-                else {
-                    const data = allocate(length);
-                    let at = 0;
-                    for (const part of entry.chunks()) {
-                        data.set(part, at);
-                        at += part.length;
-                    }
-                    bytes = propertyRange(data, context);
-                }
-                await writeDictionary(target, { length: dictionaryLength + bytes.size, count: count + 1, append: bytes });
+                // Preserve admission for the entry while writing its chunks directly into
+                // the rebuilt dictionary, without a separate store per inserted name.
+                reserve(length);
+                await writeDictionary(target, { length: dictionaryLength + length, count: count + 1, append: entry });
             }
-            else if (values.has(id)) {
+            else if (await values.get(id)) {
                 await warn(property.key, "opaque property ID collision");
                 continue;
             }
-            values.set(id, await wide(value, target));
+            await values.set(id, await wide(value, target));
         }
-        const reserve = staged?.reserve ?? ((length) => {
-            charge(length);
-            if (length > 0xffffffff || length > context.limits.outputBytes)
-                throw new SsconvertError("resource-limit", "ssconvert BIFF property output bytes limit exceeded");
-            return length;
-        });
         const encodeSection = (section) => {
             if (!section.values)
                 return { length: section.bytes.size, chunks: () => chunks(section.bytes) };
             const values = section.values;
-            let length = 8 + values.size * 8;
-            for (const value of values.values())
-                length += Math.ceil(value.size / 4) * 4;
-            // Buffered output charges the section size here, as the old allocation did.
-            reserve(length);
+            const length = values.serializedSize;
             return { length, async *chunks() {
                     const header = new Uint8Array(8), view = new DataView(header.buffer);
                     view.setUint32(0, length, true);
                     view.setUint32(4, values.size, true);
                     yield header;
                     let at = 8 + values.size * 8;
-                    for (const [id, value] of values) {
+                    for await (const [id, value] of values.entries()) {
                         charge(value.size);
                         const entry = new Uint8Array(8), view = new DataView(entry.buffer);
                         view.setUint32(0, id, true);
@@ -377,7 +367,7 @@ export async function mergeBiffProperties(book, streams, handled, context, charg
                         yield entry;
                         at += Math.ceil(value.size / 4) * 4;
                     }
-                    for (const value of values.values()) {
+                    for await (const [, value] of values.entries()) {
                         yield* chunks(value);
                         const padding = (4 - value.size % 4) % 4;
                         if (padding)
@@ -388,36 +378,61 @@ export async function mergeBiffProperties(book, streams, handled, context, charg
         for (const name of new Set([...streams.keys(), ...snapshots.keys()])) {
             for (const section of fresh.get(name) ?? [])
                 charge(1 + section.values.size);
-            const remaining = fresh.get(name)?.filter(section => [...section.values.keys()].some(id => id >= 2)) ?? [];
-            if (!old.has(name) && remaining.some(section => section.guid === biffPropertyFormats.custom) &&
-                !remaining.some(section => section.guid === biffPropertyFormats.document)) {
-                const builtin = fresh.get(name)?.find(section => section.guid === biffPropertyFormats.document);
+            const remaining = async function* () {
+                for (const section of fresh.get(name) ?? []) {
+                    charge(1);
+                    for await (const [id] of section.values.entries()) {
+                        charge(1);
+                        if (id >= 2) {
+                            yield section;
+                            break;
+                        }
+                    }
+                }
+            };
+            let custom = false, document = false;
+            if (!old.has(name))
+                for await (const section of remaining()) {
+                    custom ||= section.guid === biffPropertyFormats.custom;
+                    document ||= section.guid === biffPropertyFormats.document;
+                }
+            const builtin = custom && !document ? fresh.get(name)?.find(section => section.guid === biffPropertyFormats.document) : undefined;
+            const sections = async function* () {
+                yield* old.get(name) ?? [];
                 if (builtin)
-                    remaining.unshift(builtin);
+                    yield builtin;
+                yield* remaining();
+            };
+            let count = 0, length = 28;
+            for await (const section of sections()) {
+                charge(1);
+                count++;
+                const size = section.values?.serializedSize ?? section.bytes.size;
+                if (section.values)
+                    reserve(size);
+                length += 20 + size;
             }
-            const sections = [...old.get(name) ?? [], ...remaining];
-            if (!sections.length) {
+            if (!count) {
                 streams.delete(name);
                 continue;
             }
-            const bodies = sections.map(encodeSection), length = 28 + sections.length * 20 + bodies.reduce((sum, body) => sum + body.length, 0);
             const originalHeader = await (snapshots.get(name)?.bytes ?? propertyRange(streams.get(name), context)).read(0, 28);
             const output = { length, async *chunks() {
                     const header = new Uint8Array(originalHeader);
-                    new DataView(header.buffer).setUint32(24, sections.length, true);
+                    new DataView(header.buffer).setUint32(24, count, true);
                     yield header;
-                    let at = 28 + sections.length * 20;
-                    for (let i = 0; i < sections.length; i++) {
+                    let at = 28 + count * 20;
+                    for await (const section of sections()) {
                         charge(1);
                         const entry = new Uint8Array(20), view = new DataView(entry.buffer);
                         for (let j = 0; j < 16; j++)
-                            entry[j] = parseInt(sections[i].guid.slice(j * 2, j * 2 + 2), 16);
+                            entry[j] = parseInt(section.guid.slice(j * 2, j * 2 + 2), 16);
                         view.setUint32(16, at, true);
                         yield entry;
-                        at += bodies[i].length;
+                        at += section.values?.serializedSize ?? section.bytes.size;
                     }
-                    for (const body of bodies)
-                        yield* body.chunks();
+                    for await (const section of sections())
+                        yield* encodeSection(section).chunks();
                 } };
             if (staged) {
                 reserve(length);

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

@@ -46,7 +46,7 @@ export async function readBiffProperties(streams, context, accountText, accountW
         accountWork(file.size);
         const sections = readPropertySectionRanges(file, admit, accountWork, context);
         let unknown = false;
-        const modeled = [];
+        const modeled = retained ? [] : undefined;
         for await (const { guid, offset, end } of sections) {
             if (!biffPropertyFields.has(guid) && guid !== custom) {
                 unknown = true;
@@ -140,7 +140,7 @@ export async function readBiffProperties(streams, context, accountText, accountW
                         }
                         accountText(key);
                         properties[key] = value;
-                        modeled.push([offset, id, key]);
+                        modeled?.push([offset, id, key]);
                         observe?.({ stream: streamName, section: offset, id, key, value });
                     }
                 });
@@ -148,7 +148,7 @@ export async function readBiffProperties(streams, context, accountText, accountW
                     unknown = true;
             });
         }
-        if (unknown && retained) {
+        if (unknown && retained && modeled) {
             if (file.size * 2 > (context.limits.workbookTextBytes ?? context.limits.inputBytes * 2))
                 throw new SsconvertError("resource-limit", "ssconvert BIFF property retention limit exceeded");
             let encoded = "";

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

@@ -1,5 +1,10 @@
 import type { CapabilityContext } from "../spreadsheet-engine/contracts.js";
 import type { BiffPropertyRange } from './biff-property-range.js';
 import type { BiffPropertySource } from './biff-encrypted-properties-write.js';
-/** Count UTF-16 units before staging; both passes retain only a bounded decoder window. */
+/** Count UTF-16 units before serialization; both passes retain only a bounded decoder window. */
+export declare function wideBiffPropertyBytes(source: BiffPropertyRange, context: CapabilityContext, charge: (amount: number) => void, reserve: (length: number) => number): Promise<{
+    size: number;
+    chunks(): AsyncIterable<Uint8Array>;
+}>;
+/** Convenience API for callers that need an independently owned range source. */
 export declare function stageWideBiffProperty(source: BiffPropertyRange, context: CapabilityContext, charge: (amount: number) => void, reserve: (length: number) => number): Promise<BiffPropertySource>;

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

@@ -1,20 +1,24 @@
 import { stagePropertyBytes } from './biff-property-bytes.js';
-/** Count UTF-16 units before staging; both passes retain only a bounded decoder window. */
-export async function stageWideBiffProperty(source, context, charge, reserve) {
+/** Count UTF-16 units before serialization; both passes retain only a bounded decoder window. */
+export async function wideBiffPropertyBytes(source, context, charge, reserve) {
     reserve(source.size);
     const text = source.slice(8, await source.u32(4) - 1);
     const parts = async function* () {
+        context.signal.throwIfAborted();
         const decoder = new TextDecoder('utf-8', { fatal: true, ignoreBOM: true });
         for (let at = 0; at < text.size;) {
+            context.signal.throwIfAborted();
             const bytes = await text.read(at, Math.min(8192, text.size - at));
             at += bytes.length;
             try {
+                context.signal.throwIfAborted();
                 yield decoder.decode(bytes, { stream: true });
             }
             finally {
                 bytes.fill(0);
             }
         }
+        context.signal.throwIfAborted();
         yield decoder.decode();
     };
     let units = 0;
@@ -22,7 +26,8 @@ export async function stageWideBiffProperty(source, context, charge, reserve) {
         units += part.length;
     charge(units);
     const length = reserve(8 + (units + 1) * 2);
-    return stagePropertyBytes({ length, async *chunks() {
+    return { size: length, async *chunks() {
+            context.signal.throwIfAborted();
             const header = new Uint8Array(8), view = new DataView(header.buffer);
             view.setUint32(0, 31, true);
             view.setUint32(4, units + 1, true);
@@ -36,10 +41,16 @@ export async function stageWideBiffProperty(source, context, charge, reserve) {
                             output.setUint16(i * 2, part.charCodeAt(at + i), true);
                         yield buffer.subarray(0, size * 2);
                     }
+                context.signal.throwIfAborted();
                 yield new Uint8Array(2);
             }
             finally {
                 buffer.fill(0);
             }
-        } }, context);
+        } };
+}
+/** Convenience API for callers that need an independently owned range source. */
+export async function stageWideBiffProperty(source, context, charge, reserve) {
+    const output = await wideBiffPropertyBytes(source, context, charge, reserve);
+    return stagePropertyBytes({ length: output.size, chunks: output.chunks }, context);
 }

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

@@ -0,0 +1,36 @@
+import { type CapabilityContext } from "../spreadsheet-engine/contracts.js";
+import { BiffPropertyRange } from './biff-property-range.js';
+/** Mutable insertion order with immutable payload snapshots. Deleted payloads remain
+ * readable until close, so values can be moved between independently edited sections. */
+export declare class BiffMutablePropertyValues {
+    private readonly context;
+    private readonly charge;
+    private readonly storage;
+    private readonly index;
+    private readonly fallback;
+    private pending;
+    private closing;
+    private closed;
+    private initialized;
+    private first;
+    private last;
+    private count;
+    private paddedSize;
+    private readonly root;
+    constructor(context: CapabilityContext, charge: (amount: number) => void);
+    get size(): number;
+    get serializedSize(): number;
+    private check;
+    private allocate;
+    private io;
+    private read;
+    private write;
+    get(id: number): Promise<BiffPropertyRange | undefined>;
+    set(id: number, value: BiffPropertyRange | {
+        readonly size: number;
+        chunks(): AsyncIterable<Uint8Array>;
+    }): Promise<void>;
+    delete(id: number): Promise<boolean>;
+    entries(): AsyncGenerator<readonly [number, BiffPropertyRange]>;
+    close(): Promise<void>;
+}