@poe-platform/safe-bash 0.1.810 → 0.1.812

package/dist/spreadsheet-engine/rendering/print/control-bidi.js

@@ -0,0 +1,80 @@
+import createBidi from "bidi-js";
+const bidi = createBidi();
+/** Pango's single-paragraph FriBidi profile for mixed letter/tab/control runs. */
+export function controlBidiItems(text, direction, tick) {
+    tick(text.length * 128);
+    const types = Array.from(text, char => bidi.getBidiCharTypeName(char));
+    // Wider weak/neutral/explicit profiles need independent native qualification.
+    if (!types.includes("L") || !types.includes("R") || types.some(type => !["L", "R", "BN", "B", "S"].includes(type)))
+        return;
+    const levels = new Uint8Array(text.length);
+    let start = 0;
+    for (let index = 0; index <= text.length; index++) {
+        tick();
+        if (index < text.length && text[index] !== "\r" && text[index] !== "\u2029")
+            continue;
+        // FriBidi X8 stops explicit-level assignment at the first B. Later
+        // letters retain the initialized zero base before implicit resolution.
+        levels.set(bidi.getEmbeddingLevels(text.slice(start, index), start === 0 ? direction : "ltr").levels, start);
+        if (index < text.length)
+            levels[index] = direction === "rtl" ? 1 : 0;
+        start = index + 1;
+    }
+    // FriBidi L1 restores segment/paragraph separators to the original base.
+    let afterParagraph = false;
+    for (let index = 0; index < text.length; index++) {
+        tick();
+        if (text[index] === "\r" || text[index] === "\u2029")
+            afterParagraph = true;
+        if (afterParagraph && bidi.getBidiCharTypeName(text[index]) === "BN")
+            levels[index] = 0;
+        if (text[index] === "\t")
+            levels[index] = direction === "rtl" ? 1 : 0;
+    }
+    let reset = true;
+    for (let index = text.length - 1; index >= 0; index--) {
+        tick();
+        const char = text[index];
+        if (char === "\t" || char === "\r" || char === "\u2029")
+            reset = true;
+        else if (bidi.getBidiCharTypeName(char) !== "BN")
+            reset = false;
+        if (reset)
+            levels[index] = direction === "rtl" ? 1 : 0;
+    }
+    const items = [];
+    const itemLevels = [];
+    let previousControl = true;
+    for (let index = 0; index < text.length; index++) {
+        tick();
+        const char = text[index], level = levels[index];
+        const control = char === "\t" || char === "\r" || char === "\u2029";
+        if (control || previousControl || level !== itemLevels.at(-1)) {
+            items.push({ text: "", direction: level % 2 ? "rtl" : "ltr" });
+            itemLevels.push(level);
+        }
+        items.at(-1).text += char;
+        previousControl = control;
+    }
+    const order = items.map((_, index) => index);
+    const max = itemLevels.reduce((max, level) => Math.max(max, level), 0);
+    // Reorder the single rendered line, including controls, as Pango does.
+    for (let level = max; level >= 1; level--) {
+        for (let first = 0; first < order.length;) {
+            tick();
+            if (itemLevels[order[first]] < level) {
+                first++;
+                continue;
+            }
+            let last = first;
+            while (last < order.length && itemLevels[order[last]] >= level) {
+                tick();
+                last++;
+            }
+            for (let a = first, b = last - 1; a < b; a++, b--)
+                [order[a], order[b]] = [order[b], order[a]];
+            first = last;
+        }
+    }
+    return { items, order };
+}

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

@@ -3,10 +3,10 @@ import type { BiffPropertySource } from "./biff-encrypted-properties-write.js";
 import type { BiffRc4Cipher } from "./biff-encryption.js";
 /** Admit the outer container and reject hidden plaintext property collisions
  * before asking for a password. POI emits an empty document-summary placeholder. */
-export declare function encryptedBiffPropertyStream(streams: ReadonlyMap<string, Uint8Array> | undefined, context: CapabilityContext, charge: (amount: number) => void, propertySources?: ReadonlyMap<string, RangeSource>): Promise<Uint8Array>;
+export declare function encryptedBiffPropertyStream(streams: ReadonlyMap<string, Uint8Array> | undefined, context: CapabilityContext, charge: (amount: number) => void, propertySources?: ReadonlyMap<string, RangeSource>): Promise<Uint8Array | RangeSource>;
 /** 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 payloads directly into caller storage. Container bytes and the validated
- * descriptor table are still buffered; payload plaintext never accumulates in RAM. */
-export declare function decryptBiffPropertySources(encrypted: Uint8Array, createCipher: (block: number) => BiffRc4Cipher, context: CapabilityContext, charge: (amount: number) => void): Promise<ReadonlyMap<string, BiffPropertySource>>;
+/** Decrypt retained ciphertext and descriptor bytes directly into caller storage.
+ * Parsed descriptors and names remain resident; plaintext transfers are bounded. */
+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

@@ -23,7 +23,8 @@ export async function encryptedBiffPropertyStream(streams, context, charge, prop
             invalidBiff("duplicate encrypted property stream");
         names.add(key);
         if (key === "ENCRYPTION") {
-            encrypted = bytes;
+            const input = propertySources?.get(name);
+            encrypted = input ? propertyRange(input, context) : bytes;
             continue;
         }
         const file = propertyRange(propertySources?.get(name) ?? bytes, context);
@@ -45,9 +46,11 @@ export async function encryptedBiffPropertyStream(streams, context, charge, prop
     }
     if (!encrypted)
         throw new SsconvertError("unsupported-feature", "Unsupported ssconvert feature: encrypted Excel workbook ancillary properties require the encryption stream");
-    if (encrypted.length > context.limits.inputBytes)
+    const length = encrypted instanceof Uint8Array ? encrypted.length : encrypted.size;
+    if (length > context.limits.inputBytes)
         throw new SsconvertError("resource-limit", "ssconvert encrypted BIFF property input limit exceeded");
-    new Binary(encrypted).check(0, 8);
+    if (length < 8)
+        invalidBiff("truncated binary data");
     return encrypted;
 }
 /** MS-OFFCRYPTO 2.3.5.4: header/table restart block 0; each payload restarts its
@@ -99,7 +102,16 @@ export function decryptBiffPropertyContainer(encrypted, keyStream, context, char
     };
     try {
         check();
-        const descriptors = readEncryptedPropertyDescriptors(encrypted, decrypt, context, charge), source = new Binary(encrypted);
+        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 table = new Binary(decrypt(source.slice(offset, size), 0));
+        const reader = readEncryptedPropertyDescriptors(source, offset, size, context, charge);
+        let step = reader.next();
+        while (!step.done)
+            step = reader.next(table.slice(step.value.at, step.value.size));
+        table.bytes.fill(0);
+        const descriptors = step.value;
         for (const entry of descriptors)
             result.set(entry.name, decrypt(source.slice(entry.offset, entry.size), entry.block));
         return result;
@@ -109,16 +121,16 @@ export function decryptBiffPropertyContainer(encrypted, keyStream, context, char
         throw error;
     }
 }
-function readEncryptedPropertyDescriptors(encrypted, decrypt, context, charge) {
-    if (encrypted.length > context.limits.inputBytes)
-        throw new SsconvertError("resource-limit", "ssconvert encrypted BIFF property input limit exceeded");
-    const source = new Binary(encrypted), header = new Binary(decrypt(source.slice(0, 8), 0));
-    const offset = header.u32(0), size = header.u32(4);
-    header.bytes.fill(0);
+function propertyTableRange(bytes, source) {
+    const header = new Binary(bytes), offset = header.u32(0), size = header.u32(4);
+    bytes.fill(0);
     if (offset < 8 || size < 4)
         invalidBiff("invalid encrypted property descriptor range");
     source.check(offset, size);
-    const table = new Binary(decrypt(source.slice(offset, size), 0)), count = table.u32(0);
+    return { offset, size };
+}
+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))
@@ -128,23 +140,25 @@ function readEncryptedPropertyDescriptors(encrypted, decrypt, context, charge) {
     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");
@@ -160,7 +174,6 @@ function readEncryptedPropertyDescriptors(encrypted, decrypt, context, charge) {
     }
     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++)
@@ -168,10 +181,11 @@ function readEncryptedPropertyDescriptors(encrypted, decrypt, context, charge) {
             invalidBiff("overlapping encrypted property payloads");
     return descriptors;
 }
-/** Decrypt payloads directly into caller storage. Container bytes and the validated
- * descriptor table are still buffered; payload plaintext never accumulates in RAM. */
+/** Decrypt retained ciphertext and descriptor bytes directly into caller storage.
+ * Parsed descriptors and names remain resident; plaintext transfers are bounded. */
 export async function decryptBiffPropertySources(encrypted, createCipher, context, charge) {
     const result = new Map(), owned = [];
+    const input = propertyRange(encrypted, context);
     let closed = false;
     const check = () => { context.signal.throwIfAborted(); if (closed)
         throw new SsconvertError("invalid-request", "Encrypted BIFF property reader disposed"); };
@@ -186,14 +200,16 @@ export async function decryptBiffPropertySources(encrypted, createCipher, contex
             throw new AggregateError(errors, "Encrypted BIFF property cleanup failed");
     };
     context.own(close);
-    function* chunks(bytes, block) {
+    async function* chunks(offset, size, block) {
         check();
-        charge(bytes.length * 2 + 320);
+        input.check(offset, size);
+        charge(size * 2 + 320);
         const cipher = createCipher(block);
         try {
             check();
-            for (let at = 0; at < bytes.length; at += 16384) {
-                const output = bytes.slice(at, at + 16384);
+            for (let at = 0; at < size;) {
+                const output = await input.read(offset + at, Math.min(16384, size - at), { signal: context.signal });
+                at += output.length;
                 try {
                     cipher.xor(output);
                     check();
@@ -211,19 +227,49 @@ export async function decryptBiffPropertySources(encrypted, createCipher, contex
     }
     try {
         check();
-        const descriptors = readEncryptedPropertyDescriptors(encrypted, (bytes, block) => {
-            const output = new Uint8Array(bytes.length);
+        if (input.size > context.limits.inputBytes)
+            throw new SsconvertError("resource-limit", "ssconvert encrypted BIFF property input limit exceeded");
+        const decrypt = async (offset, size) => {
+            input.check(offset, size);
+            const output = new Uint8Array(size);
             owned.push(output);
             let at = 0;
-            for (const part of chunks(bytes, block)) {
+            for await (const part of chunks(offset, size, 0)) {
                 output.set(part, at);
                 at += part.length;
             }
             return output;
-        }, context, charge);
+        };
+        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();
+        try {
+            while (!step.done) {
+                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();
+        const descriptors = step.value;
         for (const entry of descriptors) {
-            const bytes = encrypted.subarray(entry.offset, entry.offset + entry.size);
-            const source = await stagePropertyBytes({ length: entry.size, chunks: () => chunks(bytes, entry.block) }, context, context.limits.inputBytes);
+            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();
         }

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

@@ -339,7 +339,7 @@ export async function decryptBiffRecords(records, revision, context, streams, pr
             }
         };
         // Staging must finish while the block-key base still exists.
-        return context.createWorkingStorage ? await decryptBiffPropertySources(properties, createCipher, context, admit) :
+        return context.createWorkingStorage || !(properties instanceof Uint8Array) ? await decryptBiffPropertySources(properties, createCipher, context, admit) :
             decryptBiffPropertyContainer(properties, keyStream, context, admit, createCipher);
     }
     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-property-bytes.d.ts

@@ -6,4 +6,7 @@ export type BiffPropertyBytes = Uint8Array | {
 };
 export declare function propertyChunks(value: BiffPropertyBytes): Iterable<Uint8Array>;
 /** Consume lazy serialization once into caller storage; never retain emitted chunks. */
-export declare function stagePropertyBytes(value: BiffPropertyBytes, context: CapabilityContext, maximumBytes?: number): Promise<BiffPropertySource>;
+export declare function stagePropertyBytes(value: BiffPropertyBytes | {
+    readonly length: number;
+    chunks(): AsyncIterable<Uint8Array>;
+}, context: CapabilityContext, maximumBytes?: number): Promise<BiffPropertySource>;

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

@@ -61,7 +61,7 @@ export async function stagePropertyBytes(value, context, maximumBytes = context.
                 count = 0;
             };
             try {
-                for (const part of propertyChunks(value)) {
+                for await (const part of value instanceof Uint8Array ? propertyChunks(value) : value.chunks()) {
                     check();
                     if (part.length > source.size - written - count)
                         throw new SsconvertError('io', 'Invalid BIFF property serialization size');

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

@@ -100,7 +100,7 @@ export async function readBiffRange(input, context, probe = false) {
                 // Only these ancillary payloads are interpreted by the existing reader.
                 // Keep other names for its name/work admission, without copying ignored streams.
                 const needed = ["ENCRYPTION", "\u0005SUMMARYINFORMATION", "\u0005DOCUMENTSUMMARYINFORMATION"].includes(name.toUpperCase());
-                if (needed && name.toUpperCase() !== "ENCRYPTION" && recordStore) {
+                if (needed && recordStore) {
                     propertySources.set(name, { size: stream.size, async read(at, count, options) {
                             try {
                                 return await stream.read(at, count, options);

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

@@ -3,7 +3,7 @@ import { parseA1 } from "../spreadsheet-ast/index.js";
 import { metadataNode } from "../spreadsheet-engine/codecs/xlsx-write-support.js";
 import { words } from "./biff-write-binary.js";
 import { biffString } from "./biff-write.js";
-import { biffProtectionPermissions } from "./biff-metadata.js";
+import { biffProtectionPermissions, biffHeaderParts } from "./biff-metadata.js";
 import { biffFontWidth } from "./biff-font-widths.js";
 import { writeBiffLabelRanges } from "./biff-label-ranges.js";
 function concat(...parts) {
@@ -442,6 +442,15 @@ export class BiffMetadataWriter {
                     text += source[at] === "&" ? "&&" : source[at];
                 }
             }
+            const original = sheet.view?.[name === "Header" ? "printHeader" : "printFooter"];
+            if (node && typeof original === "string") {
+                this.charge(original.length);
+                const sections = biffHeaderParts(original);
+                // Keep the imported token spelling (including formatting controls)
+                // when the normalized sections are unchanged. Explicit edits win.
+                if (Object.entries(sections).every(([side, value]) => value === (node.attributes[side] ?? "")))
+                    text = original;
+            }
             await output.record(opcode, biffString(text, revision, this.context, revision === 8 ? 2 : 1));
         }
         for (const [name, opcode] of [["hPageBreaks", 0x1b], ["vPageBreaks", 0x1a]]) {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@poe-platform/safe-bash",
-  "version": "0.1.810",
+  "version": "0.1.812",
   "description": "Extensible virtual shell with pluggable filesystems and streaming commands",
   "type": "module",
   "license": "MIT",
@@ -1407,7 +1407,7 @@
     "access": "public"
   },
   "dependencies": {
-    "@poe-platform/safe-fs": "0.1.810",
+    "@poe-platform/safe-fs": "0.1.812",
     "pdf-lib": "1.17.1",
     "@types/node": "^25.2.2",
     "@formatjs/intl-numberformat": "9.4.0",
@@ -1420,6 +1420,7 @@
     "parse5": "7.3.0",
     "@pdf-lib/fontkit": "1.1.1",
     "linebreak": "^1.1.0",
+    "bidi-js": "1.1.0",
     "saxes": "^6.0.0",
     "temporal-polyfill": "1.0.4",
     "@formatjs/intl-localematcher": "0.8.13",
@@ -2729,9 +2730,11 @@
     "./dist/spreadsheet-engine/rendering/images/index.js",
     "./dist/spreadsheet-engine/rendering/images/profile-raster.js",
     "./dist/spreadsheet-engine/rendering/images/scene.js",
+    "./dist/spreadsheet-engine/rendering/print/bidi-runs.js",
     "./dist/spreadsheet-engine/rendering/print/blank-styles.js",
     "./dist/spreadsheet-engine/rendering/print/border-junctions.js",
     "./dist/spreadsheet-engine/rendering/print/cell-style.js",
+    "./dist/spreadsheet-engine/rendering/print/control-bidi.js",
     "./dist/spreadsheet-engine/rendering/print/diagonal-borders.js",
     "./dist/spreadsheet-engine/rendering/print/font-normalization-data.js",
     "./dist/spreadsheet-engine/rendering/print/font-normalization.js",