@poe-platform/safe-bash 0.1.806 → 0.1.807

package/dist/spreadsheet-engine/rendering/print/font-normalization.d.ts

@@ -0,0 +1,3 @@
+/** Normalize only the qualified default-shaper Latin/Greek/Cyrillic clusters.
+ * Original logical text belongs in ActualText; this result is for glyph shaping. */
+export declare function normalizeFontText(value: string, supported: ReadonlySet<number>, tick: (amount?: number) => void): string;

package/dist/spreadsheet-engine/rendering/print/font-normalization.js

@@ -0,0 +1,113 @@
+// Font-aware canonical diacritics, adapted from HarfBuzz10.2.0.
+// See font-normalization-NOTICE.md for scope, source identities and licenses.
+import { fontCharacterProperties, fontDecompositions } from './font-normalization-data.js';
+const decompositions = new Map(fontDecompositions.map(([point, first, second]) => [point, [first, second]]));
+const compositions = new Map(fontDecompositions.filter(row => row[3] !== 0).map(([point, first, second]) => [`${first},${second}`, point]));
+/** Normalize only the qualified default-shaper Latin/Greek/Cyrillic clusters.
+ * Original logical text belongs in ActualText; this result is for glyph shaping. */
+export function normalizeFontText(value, supported, tick) {
+    tick(value.length);
+    const properties = (point) => {
+        let from = 0, to = fontCharacterProperties.length - 1;
+        while (from <= to) {
+            tick();
+            const middle = (from + to) >>> 1, row = fontCharacterProperties[middle];
+            if (point < row[0])
+                to = middle - 1;
+            else if (point > row[1])
+                from = middle + 1;
+            else
+                return [row[2], row[3]];
+        }
+        return [0, 0];
+    };
+    const decompose = (point, shortest) => {
+        tick();
+        const pair = decompositions.get(point);
+        if (!pair || pair[1] !== 0 && !supported.has(pair[1]))
+            return;
+        const [first, second] = pair;
+        if (shortest && supported.has(first))
+            return second === 0 ? [first] : [first, second];
+        const nested = decompose(first, shortest);
+        if (nested) {
+            if (second !== 0)
+                nested.push(second);
+            return nested;
+        }
+        if (supported.has(first))
+            return second === 0 ? [first] : [first, second];
+    };
+    const result = [];
+    for (let start = 0; start < value.length;) {
+        tick();
+        const first = value.codePointAt(start), input = [first];
+        let end = start + (first > 0xffff ? 2 : 1), eligible = (properties(first)[0] & 2) !== 0;
+        let variation = first >= 0xfe00 && first <= 0xfe0f || first >= 0xe0100 && first <= 0xe01ef;
+        while (end < value.length) {
+            tick();
+            const point = value.codePointAt(end), flags = properties(point)[0];
+            if ((flags & 1) === 0)
+                break;
+            eligible &&= (flags & 4) !== 0;
+            variation ||= point >= 0xfe00 && point <= 0xfe0f || point >= 0xe0100 && point <= 0xe01ef;
+            input.push(point);
+            end += point > 0xffff ? 2 : 1;
+        }
+        if (!eligible)
+            result.push(value.slice(start, end));
+        else {
+            const points = [];
+            for (const point of input) {
+                tick();
+                const expanded = variation || input.length === 1 && supported.has(point) ? [point] : decompose(point, input.length === 1) ?? [point];
+                for (const child of expanded) {
+                    const [flags, ccc] = properties(child);
+                    points.push({ point: child, mark: (flags & 1) !== 0, ccc });
+                }
+            }
+            for (let at = 0; at < points.length; at++) {
+                tick();
+                if (points[at].ccc === 0)
+                    continue;
+                let end = at + 1;
+                while (end < points.length && points[end].ccc !== 0) {
+                    tick();
+                    end++;
+                }
+                // HarfBuzz's default shaper bounds mark reordering to32characters.
+                if (end - at <= 32) {
+                    const sorted = points.slice(at, end).sort((left, right) => { tick(); return left.ccc - right.ccc; });
+                    for (let index = 0; index < sorted.length; index++) {
+                        tick();
+                        points[at + index] = sorted[index];
+                    }
+                }
+                at = end - 1;
+            }
+            const output = [];
+            let starter = 0;
+            for (const point of points) {
+                tick();
+                const combined = point.mark && output[starter] && (starter === output.length - 1 || output[output.length - 1].ccc < point.ccc)
+                    ? compositions.get(`${output[starter].point},${point.point}`) : undefined;
+                if (combined !== undefined && supported.has(combined)) {
+                    const [flags, ccc] = properties(combined);
+                    output[starter] = { point: combined, mark: (flags & 1) !== 0, ccc };
+                }
+                else {
+                    output.push(point);
+                    if (point.ccc === 0)
+                        starter = output.length - 1;
+                }
+            }
+            for (const point of output) {
+                tick();
+                result.push(String.fromCodePoint(point.point));
+            }
+        }
+        start = end;
+    }
+    tick();
+    return result.join('');
+}

package/dist/spreadsheet-engine/rendering/print/font-shaping.d.ts

@@ -0,0 +1,18 @@
+import type { Font, GlyphRun } from "@pdf-lib/fontkit";
+import { type CapabilityContext } from "../../contracts.js";
+export interface FontShapingWebAssembly {
+    readonly CompileError: abstract new (...args: never[]) => Error;
+    readonly Memory: abstract new (...args: never[]) => {
+        readonly buffer: ArrayBuffer;
+        grow(pages: number): number;
+    };
+    compile(bytes: Uint8Array<ArrayBuffer>): Promise<object>;
+    instantiate(module: object, imports: Record<string, Record<string, (...args: number[]) => number | void>>): Promise<{
+        readonly exports: Readonly<Record<string, unknown>>;
+    }>;
+}
+export declare function createFontShaper(context: CapabilityContext, tick: (amount?: number) => void): {
+    dispose: () => void;
+    addFont(bytes: Uint8Array, metrics: Font): Promise<void>;
+    shape(metrics: Font, text: string): GlyphRun;
+};

package/dist/spreadsheet-engine/rendering/print/font-shaping.js

@@ -0,0 +1,271 @@
+import { SsconvertError } from "../../contracts.js";
+const wasm = globalThis.WebAssembly;
+// Only immutable compiled code is shared. Font data, native handles and failure
+// state belong to one conversion and are discarded together on any failure.
+let compiled;
+let activeShapers = 0;
+export function createFontShaper(context, tick) {
+    activeShapers++;
+    let exports, disposed = false, fallback = false;
+    const fonts = new Map();
+    const dispose = () => {
+        if (!disposed) {
+            for (const entry of fonts.values()) {
+                if (entry && exports) {
+                    try {
+                        if (typeof exports.hb_font_destroy === "function")
+                            exports.hb_font_destroy(entry.font);
+                        if (typeof exports.free === "function")
+                            exports.free(entry.data);
+                    }
+                    catch { /* Cleanup is best effort if a WASM export fails. */ }
+                }
+            }
+            const mem = exports?.memory;
+            if (typeof wasm?.Memory === "function" && mem instanceof wasm.Memory) {
+                try {
+                    mem.buffer.transfer?.(0);
+                }
+                catch { /* Host memory detachment is best effort. */ }
+            }
+            disposed = true;
+            if (--activeShapers <= 0) {
+                activeShapers = 0;
+                compiled = undefined;
+            }
+            const gc = globalThis.gc;
+            if (typeof gc === "function") {
+                try {
+                    gc();
+                }
+                catch { /* Optional host collection must not prevent cleanup. */ }
+            }
+        }
+        exports = undefined;
+        fonts.clear();
+    };
+    context.own(dispose); // Register before asynchronous compilation or acquisition.
+    const fail = () => { dispose(); throw new SsconvertError("resource-limit", "ssconvert PDF font shaping could not complete"); };
+    const call = (name, ...args) => {
+        const fn = exports?.[name];
+        if (disposed || typeof fn !== "function")
+            return fail();
+        try {
+            return fn(...args);
+        }
+        catch {
+            return fail();
+        }
+    };
+    const memory = () => {
+        const value = exports?.memory;
+        if (disposed || !wasm || !(value instanceof wasm.Memory))
+            return fail();
+        return value;
+    };
+    const view = (pointer, length, alignment = 1) => {
+        const buffer = memory().buffer;
+        if (!Number.isSafeInteger(pointer) || pointer <= 0 || pointer % alignment || !Number.isSafeInteger(length) || length < 0 || pointer + length > buffer.byteLength)
+            return fail();
+        return new DataView(buffer, pointer, length);
+    };
+    const check = (buffer = 0) => {
+        tick();
+        if (call("ssconvert_hb_failure", buffer) !== 0)
+            fail();
+    };
+    return {
+        dispose,
+        async addFont(bytes, metrics) {
+            tick(bytes.length);
+            if (disposed || bytes.length > context.limits.inputBytes)
+                fail();
+            if (fallback) {
+                fonts.set(metrics, null);
+                return;
+            }
+            if (!exports) {
+                let module;
+                try {
+                    if (typeof wasm?.compile === "function") {
+                        const { harfbuzzBase64 } = await import("./harfbuzz/data.js");
+                        compiled ??= (() => {
+                            const binary = atob(harfbuzzBase64);
+                            const decoded = new Uint8Array(binary.length);
+                            for (let i = 0; i < binary.length; i++)
+                                decoded[i] = binary.charCodeAt(i);
+                            return wasm.compile(decoded).finally(() => {
+                                if (typeof decoded.buffer.transfer === "function") {
+                                    try {
+                                        decoded.buffer.transfer(0);
+                                    }
+                                    catch { /* Detachment is best effort for host buffers. */ }
+                                }
+                            }).catch(error => {
+                                compiled = undefined;
+                                throw error;
+                            });
+                        })();
+                        module = await compiled;
+                    }
+                }
+                catch (error) {
+                    if (!wasm || !(error instanceof wasm.CompileError))
+                        throw error;
+                }
+                tick();
+                if (disposed)
+                    fail();
+                if (!module || !wasm) {
+                    fallback = true;
+                    fonts.set(metrics, null);
+                    return;
+                }
+                const unexpected = () => fail();
+                const instance = await wasm.instantiate(module, {
+                    wasi_snapshot_preview1: { proc_exit: unexpected },
+                    env: { _emscripten_runtime_keepalive_clear: unexpected, _abort_js: unexpected, _setitimer_js: unexpected,
+                        emscripten_resize_heap(requested) {
+                            const current = memory();
+                            if (!Number.isSafeInteger(requested) || requested < current.buffer.byteLength)
+                                return fail();
+                            try {
+                                current.grow(Math.ceil((requested - current.buffer.byteLength) / 65536));
+                                return 1;
+                            }
+                            catch {
+                                return fail();
+                            }
+                        } }
+                });
+                tick();
+                if (disposed)
+                    fail();
+                exports = instance.exports;
+                call("__wasm_call_ctors");
+                check();
+            }
+            try {
+                const data = call("malloc", bytes.length);
+                new Uint8Array(view(data, bytes.length).buffer, data, bytes.length).set(bytes);
+                // READONLY: the owned input remains alive until the font/instance dies.
+                const blob = call("hb_blob_create", data, bytes.length, 1, 0, 0);
+                const face = call("hb_face_create", blob, 0);
+                const font = call("hb_font_create", face);
+                check();
+                if (!blob || !face || !font || call("hb_face_get_upem", face) !== metrics.unitsPerEm)
+                    fail();
+                call("hb_font_set_scale", font, metrics.unitsPerEm, metrics.unitsPerEm);
+                call("hb_face_destroy", face);
+                call("hb_blob_destroy", blob);
+                fonts.set(metrics, { font, data });
+            }
+            catch (error) {
+                dispose();
+                throw error;
+            }
+        },
+        shape(metrics, text) {
+            tick(text.length);
+            const selected = fonts.get(metrics);
+            if (!fonts.has(metrics) || disposed || text.length > context.limits.inputBytes / 2)
+                return fail();
+            let buffer = 0, input = 0;
+            try {
+                if (!selected) {
+                    const run = metrics.layout(text);
+                    if (run.glyphs.length > (context.limits.workbookWork ?? context.limits.inputBytes))
+                        fail();
+                    tick(run.glyphs.length * 20);
+                    // Preserve GlyphRun getters and own glyph mappings without modifying
+                    // fontkit's cached glyph instances or their code point arrays.
+                    return Object.create(run, { glyphs: { value: run.glyphs.map(glyph => Object.create(glyph, { codePoints: { value: [...glyph.codePoints] } })) } });
+                }
+                buffer = call("hb_buffer_create");
+                input = call("malloc", Math.max(2, text.length * 2));
+                const utf16 = view(input, Math.max(2, text.length * 2), 2);
+                for (let i = 0; i < text.length; i++)
+                    utf16.setUint16(i * 2, text.charCodeAt(i), true);
+                call("hb_buffer_add_utf16", buffer, input, text.length, 0, text.length);
+                call("hb_buffer_set_cluster_level", buffer, 1);
+                call("hb_buffer_guess_segment_properties", buffer);
+                check(buffer);
+                const complete = call("hb_shape_full", selected.font, buffer, 0, 0, 0);
+                check(buffer);
+                if (!complete || call("hb_buffer_get_content_type", buffer) !== 2)
+                    fail();
+                const length = call("hb_buffer_get_length", buffer);
+                if (!Number.isSafeInteger(length) || length < 0 || length > (context.limits.workbookWork ?? context.limits.inputBytes))
+                    fail();
+                tick(length * 20);
+                const infoPointer = call("hb_buffer_get_glyph_infos", buffer, 0);
+                const positionPointer = call("hb_buffer_get_glyph_positions", buffer, 0);
+                const direction = call("hb_buffer_get_direction", buffer);
+                const script = call("hb_buffer_get_script", buffer);
+                const languagePointer = call("hb_language_to_string", call("hb_buffer_get_language", buffer));
+                let language = "";
+                if (languagePointer) {
+                    for (let i = 0; i < 256; i++) {
+                        const byte = view(languagePointer + i, 1).getUint8(0);
+                        if (byte === 0)
+                            break;
+                        language += String.fromCharCode(byte);
+                        if (i === 255)
+                            fail();
+                    }
+                }
+                check(buffer);
+                // Acquire views after all native calls that could grow the memory.
+                const infos = length ? view(infoPointer, length * 20, 4) : undefined;
+                const positions = length ? view(positionPointer, length * 20, 4) : undefined;
+                const rows = Array.from({ length }, (_, i) => ({
+                    id: infos.getUint32(i * 20, true), cluster: infos.getUint32(i * 20 + 8, true),
+                    xAdvance: positions.getInt32(i * 20, true), yAdvance: positions.getInt32(i * 20 + 4, true),
+                    xOffset: positions.getInt32(i * 20 + 8, true), yOffset: positions.getInt32(i * 20 + 12, true)
+                }));
+                const clusters = [...new Set(rows.map(row => row.cluster))].sort((a, b) => a - b);
+                const codePoints = new Map();
+                for (const [index, start] of clusters.entries()) {
+                    if (start >= text.length || (start > 0 && text.charCodeAt(start) >= 0xdc00 && text.charCodeAt(start) <= 0xdfff))
+                        fail();
+                    codePoints.set(start, [...text.slice(start, clusters[index + 1] ?? text.length)].map(character => character.codePointAt(0)));
+                }
+                let advanceWidth = 0, advanceHeight = 0, minX = Infinity, minY = Infinity, maxX = -Infinity, maxY = -Infinity;
+                const glyphs = rows.map(row => {
+                    tick();
+                    if (row.id >= metrics.numGlyphs)
+                        fail();
+                    // fontkit caches glyphs by ID. Own Unicode mappings without mutating
+                    // that cache when multiple clusters or cells reuse the same outline.
+                    const glyph = Object.create(metrics.getGlyph(row.id), { codePoints: { value: codePoints.get(row.cluster) } });
+                    const box = glyph.bbox;
+                    minX = Math.min(minX, advanceWidth + row.xOffset + box.minX);
+                    minY = Math.min(minY, advanceHeight + row.yOffset + box.minY);
+                    maxX = Math.max(maxX, advanceWidth + row.xOffset + box.maxX);
+                    maxY = Math.max(maxY, advanceHeight + row.yOffset + box.maxY);
+                    advanceWidth += row.xAdvance;
+                    advanceHeight += row.yAdvance;
+                    return glyph;
+                });
+                if (!length)
+                    minX = minY = maxX = maxY = 0;
+                return { glyphs, positions: rows, advanceWidth, advanceHeight,
+                    script: String.fromCharCode(script >>> 24, script >>> 16 & 255, script >>> 8 & 255, script & 255),
+                    direction: direction === 4 ? "ltr" : direction === 5 ? "rtl" : null, language: language || null, features: {},
+                    bbox: { minX, minY, maxX, maxY, width: maxX - minX, height: maxY - minY } };
+            }
+            catch (error) {
+                dispose();
+                throw error;
+            }
+            finally {
+                if (!disposed) {
+                    if (buffer)
+                        call("hb_buffer_destroy", buffer);
+                    if (input)
+                        call("free", input);
+                }
+            }
+        }
+    };
+}