@poe-platform/safe-bash 0.1.806 → 0.1.807

package/dist/spreadsheet-engine/rendering/images/codecs.js

@@ -0,0 +1,253 @@
+import { SsconvertError } from "../../contracts.js";
+import { ImageExportError, profileImageTargets } from "./formats.js";
+import { encodeProfileRaster } from "./profile-raster.js";
+const encoder = new TextEncoder();
+function number(value) {
+    if (!Number.isFinite(value))
+        throw new ImageExportError("Invalid image geometry");
+    return String(value === 0 ? 0 : value);
+}
+function color(text) {
+    if (text.length !== 7 || text[0] !== "#" || !Array.from(text.slice(1)).every(char => "0123456789abcdefABCDEF".includes(char)))
+        throw new ImageExportError("Unsupported image color");
+    return [Number.parseInt(text.slice(1, 3), 16) / 255, Number.parseInt(text.slice(3, 5), 16) / 255, Number.parseInt(text.slice(5, 7), 16) / 255];
+}
+function literal(text) {
+    if (Array.from(text).some(char => char.codePointAt(0) > 126 || char.codePointAt(0) < 32))
+        throw new ImageExportError("Unsupported image text encoding");
+    return text.replaceAll("\\", "\\\\").replaceAll("(", "\\(").replaceAll(")", "\\)");
+}
+function xml(text, context) {
+    let escaped = "", bytes = 0;
+    bounded(text.length, context.limits.workbookWork ?? context.limits.inputBytes + context.limits.cells * 32, "text work");
+    for (const char of text) {
+        context.signal.throwIfAborted();
+        const point = char.codePointAt(0);
+        if (!(point === 9 || point === 10 || point === 13 || point >= 32 && point <= 0xd7ff || point >= 0xe000 && point <= 0xfffd || point >= 0x10000 && point <= 0x10ffff))
+            throw new ImageExportError("Unsupported image text encoding");
+        const value = char === "&" ? "&amp;" : char === "<" ? "&lt;" : char === ">" ? "&gt;" : char === '"' ? "&quot;" : char;
+        bytes += value.length > char.length ? value.length : point <= 0x7f ? 1 : point <= 0x7ff ? 2 : point <= 0xffff ? 3 : 4;
+        bounded(bytes, context.limits.outputBytes, "output bytes");
+        escaped += value;
+    }
+    return escaped;
+}
+function utf8Length(text, context) {
+    let bytes = 0;
+    for (const char of text) {
+        context.signal.throwIfAborted();
+        const point = char.codePointAt(0);
+        bytes += point <= 0x7f ? 1 : point <= 0x7ff ? 2 : point <= 0xffff ? 3 : 4;
+        bounded(bytes, context.limits.outputBytes, "output bytes");
+    }
+    return bytes;
+}
+function bounded(amount, maximum, name) {
+    if (!Number.isSafeInteger(amount) || amount < 0 || amount > maximum)
+        throw new SsconvertError("resource-limit", `ssconvert image ${name} limit exceeded`);
+}
+function pngChunk(type, data) {
+    const bytes = new Uint8Array(data.length + 12);
+    const view = new DataView(bytes.buffer);
+    view.setUint32(0, data.length);
+    bytes.set(encoder.encode(type), 4);
+    bytes.set(data, 8);
+    let crc = 0xffffffff;
+    for (const byte of bytes.subarray(4, bytes.length - 4)) {
+        crc ^= byte;
+        for (let bit = 0; bit < 8; bit++)
+            crc = (crc >>> 1) ^ ((crc & 1) ? 0xedb88320 : 0);
+    }
+    view.setUint32(bytes.length - 4, (crc ^ 0xffffffff) >>> 0);
+    return bytes;
+}
+function join(parts) {
+    const bytes = new Uint8Array(parts.reduce((sum, part) => sum + part.length, 0));
+    let offset = 0;
+    for (const part of parts) {
+        bytes.set(part, offset);
+        offset += part.length;
+    }
+    return bytes;
+}
+/** RFC 1950/1951 stored blocks. Pixel fidelity is independent of compression. */
+function deflateStored(raw, context) {
+    const parts = [new Uint8Array([0x78, 0x01])];
+    let a = 1, b = 0;
+    for (let offset = 0; offset < raw.length; offset += 65535) {
+        context.signal.throwIfAborted();
+        const block = raw.subarray(offset, Math.min(offset + 65535, raw.length));
+        const header = new Uint8Array(5);
+        const view = new DataView(header.buffer);
+        header[0] = offset + block.length === raw.length ? 1 : 0;
+        view.setUint16(1, block.length, true);
+        view.setUint16(3, 65535 - block.length, true);
+        parts.push(header, block);
+        for (const byte of block) {
+            a = (a + byte) % 65521;
+            b = (b + a) % 65521;
+        }
+    }
+    const checksum = new Uint8Array(4);
+    new DataView(checksum.buffer).setUint32(0, ((b << 16) | a) >>> 0);
+    parts.push(checksum);
+    return join(parts);
+}
+function raster(surface, context) {
+    const value = surface.raster;
+    if (!value)
+        throw new ImageExportError("Missing profile-specific raster surface");
+    if (!Number.isSafeInteger(value.width) || !Number.isSafeInteger(value.height) || value.width < 1 || value.height < 1 || value.width > 32767 || value.height > 32767)
+        throw new ImageExportError("Invalid raster surface geometry");
+    bounded(value.width * value.height * 4, context.limits.workbookWork ?? context.limits.inputBytes + context.limits.cells * 32, "raster work");
+    if (value.rgba.byteLength !== value.width * value.height * 4)
+        throw new ImageExportError("Invalid raster surface bytes");
+    return value;
+}
+function encodePng(surface, context) {
+    const { width, height, rgba } = raster(surface, context);
+    const length = (width * 4 + 1) * height;
+    bounded(length + Math.ceil(length / 65535) * 5 + 63, context.limits.outputBytes, "output bytes");
+    const raw = new Uint8Array(length);
+    for (let row = 0; row < height; row++) {
+        context.signal.throwIfAborted();
+        raw.set(rgba.subarray(row * width * 4, (row + 1) * width * 4), row * (width * 4 + 1) + 1);
+    }
+    const ihdr = new Uint8Array(13);
+    const view = new DataView(ihdr.buffer);
+    view.setUint32(0, width);
+    view.setUint32(4, height);
+    ihdr[8] = 8;
+    ihdr[9] = 6;
+    return join([new Uint8Array([137, 80, 78, 71, 13, 10, 26, 10]), pngChunk("IHDR", ihdr), pngChunk("IDAT", deflateStored(raw, context)), pngChunk("IEND", new Uint8Array())]);
+}
+function vectorContent(surface, format, context) {
+    let body = "";
+    let bodyBytes = 0;
+    let work = 0;
+    const maximum = context.limits.workbookWork ?? context.limits.inputBytes + context.limits.cells * 32;
+    const paint = (fill, stroke = false) => color(fill).map(number).join(" ") + (format === "pdf" ? stroke ? " RG\n" : " rg\n" : " setrgbcolor\n");
+    const append = (text) => { bodyBytes += utf8Length(text, context); bounded(bodyBytes, context.limits.outputBytes, "output bytes"); body += text; };
+    for (const command of surface.commands) {
+        context.signal.throwIfAborted();
+        bounded(++work, maximum, "vector work");
+        if (command.kind === "rectangle") {
+            const box = [command.x, command.y, command.width, command.height].map(number);
+            color(command.fill);
+            if (format === "svg")
+                append(`<rect x="${box[0]}" y="${box[1]}" width="${box[2]}" height="${box[3]}" fill="${command.fill}"/>\n`);
+            else
+                append(paint(command.fill) + box.join(" ") + (format === "pdf" ? " re f\n" : " rectfill\n"));
+        }
+        else if (command.kind === "text") {
+            color(command.fill);
+            if (command.font !== "Helvetica")
+                throw new ImageExportError("Unsupported image font");
+            work += command.text.length;
+            bounded(work, maximum, "text work");
+            if (!(command.size > 0))
+                throw new ImageExportError("Invalid image font size");
+            const x = number(command.x), y = number(command.y), size = number(command.size);
+            if (format === "svg")
+                append(`<text x="${x}" y="${y}" font-family="${command.font}" font-size="${size}" fill="${command.fill}">${xml(command.text, context)}</text>\n`);
+            else if (format === "pdf")
+                append(paint(command.fill) + `BT /F1 ${size} Tf 1 0 0 -1 ${x} ${y} Tm (${literal(command.text)}) Tj ET\n`);
+            else
+                append(paint(command.fill) + `gsave ${x} ${y} translate 1 -1 scale /Helvetica findfont ${size} scalefont setfont 0 0 moveto (${literal(command.text)}) show grestore\n`);
+        }
+        else {
+            if (command.fill)
+                color(command.fill);
+            if (command.stroke)
+                color(command.stroke);
+            if (command.lineWidth !== undefined && !(command.lineWidth >= 0))
+                throw new ImageExportError("Invalid image line width");
+            let path = "";
+            for (const point of command.commands) {
+                context.signal.throwIfAborted();
+                bounded(++work, maximum, "vector work");
+                let segment;
+                if (point.kind === "close")
+                    segment = format === "svg" ? "Z " : format === "pdf" ? "h\n" : "closepath\n";
+                else {
+                    const coordinates = (point.kind === "curve" ? [point.x1, point.y1, point.x2, point.y2, point.x, point.y] : [point.x, point.y]).map(number).join(" ");
+                    segment = format === "svg" ? `${point.kind === "move" ? "M" : point.kind === "line" ? "L" : "C"}${coordinates} ` : `${coordinates} ${format === "pdf" ? point.kind === "move" ? "m" : point.kind === "line" ? "l" : "c" : point.kind === "move" ? "moveto" : point.kind === "line" ? "lineto" : "curveto"}\n`;
+                }
+                bounded(path.length + segment.length, context.limits.outputBytes, "output bytes");
+                path += segment;
+            }
+            if (format === "svg")
+                append(`<path d="${path}" fill="${command.fill ?? "none"}" stroke="${command.stroke ?? "none"}" stroke-width="${number(command.lineWidth ?? 1)}"/>\n`);
+            else if (format === "pdf")
+                append((command.fill ? paint(command.fill) : "") + (command.stroke ? paint(command.stroke, true) + `${number(command.lineWidth ?? 1)} w\n` : "") + path + (command.fill && command.stroke ? "B\n" : command.fill ? "f\n" : command.stroke ? "S\n" : "n\n"));
+            else
+                append("newpath\n" + path + (command.fill ? "gsave\n" + paint(command.fill) + "fill grestore\n" : "") + (command.stroke ? paint(command.stroke) + `${number(command.lineWidth ?? 1)} setlinewidth stroke\n` : "newpath\n"));
+        }
+    }
+    return body;
+}
+function pdf(surface, content) {
+    const objects = [
+        "<< /Type /Catalog /Pages 2 0 R >>",
+        "<< /Type /Pages /Kids [3 0 R] /Count 1 >>",
+        `<< /Type /Page /Parent 2 0 R /MediaBox [0 0 ${number(surface.width)} ${number(surface.height)}] /Resources << /Font << /F1 5 0 R >> >> /Contents 4 0 R >>`,
+        `<< /Length ${encoder.encode(content).length} >>\nstream\n${content}endstream`,
+        "<< /Type /Font /Subtype /Type1 /BaseFont /Helvetica >>"
+    ];
+    let document = "%PDF-1.7\n";
+    const offsets = [0];
+    for (const [index, object] of objects.entries()) {
+        offsets.push(encoder.encode(document).length);
+        document += `${index + 1} 0 obj\n${object}\nendobj\n`;
+    }
+    const xref = encoder.encode(document).length;
+    document += `xref\n0 ${offsets.length}\n0000000000 65535 f \n` + offsets.slice(1).map(offset => `${String(offset).padStart(10, "0")} 00000 n \n`).join("");
+    return document + `trailer\n<< /Size ${offsets.length} /Root 1 0 R >>\nstartxref\n${xref}\n%%EOF\n`;
+}
+export async function encodeGraphImage(surface, format, context) {
+    context.signal.throwIfAborted();
+    const descriptor = profileImageTargets.find(candidate => candidate.id === format);
+    if (!descriptor)
+        throw new ImageExportError("Unknown image format");
+    if (!descriptor.graphRenderable)
+        throw new ImageExportError("Unknown failure while saving image");
+    if (!(surface.width >= 1 && surface.height >= 1))
+        throw new ImageExportError("Invalid image geometry");
+    number(surface.width);
+    number(surface.height);
+    let bytes;
+    if (format === "png")
+        bytes = encodePng(surface, context);
+    else if (["bmp", "ico", "tiff"].includes(format))
+        bytes = encodeProfileRaster(raster(surface, context), format, context);
+    else if (format === "jpeg") {
+        const image = raster(surface, context);
+        const rgba = new Uint8Array(image.rgba.length);
+        for (let offset = 0; offset < rgba.length; offset += 4) {
+            if (offset % (image.width * 4) === 0)
+                context.signal.throwIfAborted();
+            const alpha = image.rgba[offset + 3];
+            for (let channel = 0; channel < 3; channel++)
+                rgba[offset + channel] = Math.floor((image.rgba[offset + channel] * alpha + 255 * (255 - alpha) + 127) / 255);
+            rgba[offset + 3] = 255;
+        }
+        const { encodeJpegImage } = await import("../../../image-ast/index.js");
+        bytes = encodeJpegImage({ width: image.width, height: image.height, data: rgba,
+            format: "raw", space: "srgb", channels: 4, depth: "uchar", density: 72, hasAlpha: false }, { quality: 75 });
+    }
+    else {
+        const content = vectorContent(surface, format, context);
+        const width = number(surface.width), height = number(surface.height);
+        if (format === "svg")
+            bytes = encoder.encode(`<?xml version="1.0" encoding="UTF-8"?>\n<svg xmlns="http://www.w3.org/2000/svg" xmlns:xlink="http://www.w3.org/1999/xlink" width="${width}" height="${height}" viewBox="0 0 ${width} ${height}">\n${content}</svg>\n`);
+        else if (format === "pdf")
+            bytes = encoder.encode(pdf(surface, `q\n1 0 0 -1 0 ${height} cm\n${content}Q\n`));
+        else {
+            const inkBox = surface.commands.length === 0 ? `0 ${Math.ceil(surface.height)} 0 ${Math.ceil(surface.height)}` : `0 0 ${Math.ceil(surface.width)} ${Math.ceil(surface.height)}`;
+            bytes = encoder.encode(`%!PS-Adobe-3.0${format === "eps" ? " EPSF-3.0" : ""}\n%%Pages: 1\n%%LanguageLevel: 2\n%%BoundingBox: ${inkBox}\n%%DocumentMedia: ${width}x${height} ${width} ${height} 0 () ()\n%%EndComments\n%%Page: 1 1\n%%PageMedia: ${width}x${height}\n%%PageBoundingBox: ${inkBox}\n${format === "eps" ? "" : `<< /PageSize [${width} ${height}] >> setpagedevice\n`}gsave\n0 ${height} translate 1 -1 scale\n${content}grestore\nshowpage\n%%EOF\n`);
+        }
+    }
+    context.signal.throwIfAborted();
+    bounded(bytes.byteLength, context.limits.outputBytes, "output bytes");
+    return bytes;
+}

package/dist/spreadsheet-engine/rendering/images/index.d.ts

@@ -0,0 +1,26 @@
+import { type CapabilityContext } from "../../contracts.js";
+import type { Sheet, Workbook } from "../../../spreadsheet-ast/index.js";
+import { type SheetObject } from "../../objects/index.js";
+import { type ObjectMetrics, type ObjectRectangle } from "../../objects/layout.js";
+import type { RenderingCapability } from "../../rendering.js";
+import { type ImageSurface } from "./codecs.js";
+export { imageFormats, profileImageTargets, ImageExportError } from "./formats.js";
+export { encodeGraphImage } from "./codecs.js";
+export type { ImageSurface, ImageCommand, ImagePathCommand } from "./codecs.js";
+export interface GraphSceneRequest {
+    readonly book: Workbook;
+    readonly sheet: Sheet;
+    readonly object: SheetObject;
+    readonly rectangle: ObjectRectangle;
+    readonly width: number;
+    readonly height: number;
+    readonly resolution: number;
+    readonly format: string;
+}
+export interface ImageRenderingOptions {
+    /** A JavaScript scene producer, never a native process or fallback. */
+    readonly renderGraph?: (request: GraphSceneRequest, context: CapabilityContext) => Promise<ImageSurface>;
+    readonly metrics?: (sheet: Sheet, context: CapabilityContext) => ObjectMetrics;
+}
+/** Owns graph filtering and native stable anchor order, not publication or filenames. */
+export declare function createImageRendering(options?: ImageRenderingOptions): RenderingCapability;

package/dist/spreadsheet-engine/rendering/images/index.js

@@ -0,0 +1,144 @@
+import { SsconvertError } from "../../contracts.js";
+import { sheetObjects } from "../../objects/index.js";
+import { objectRectangle } from "../../objects/layout.js";
+import { encodeGraphImage } from "./codecs.js";
+import { profileImageTargets, ImageExportError } from "./formats.js";
+import { graphBackground } from "./scene.js";
+export { imageFormats, profileImageTargets, ImageExportError } from "./formats.js";
+export { encodeGraphImage } from "./codecs.js";
+/** Captured C/UTC profile defaults. Explicit persisted metrics override these. */
+function sheetMetrics(sheet, context) {
+    let work = 0;
+    const maximum = context.limits.workbookWork ?? context.limits.inputBytes + context.limits.cells * 32;
+    const axis = (entries, fallback) => {
+        const sorted = [...(entries ?? [])].sort((a, b) => a.index - b.index);
+        const indices = [], adjustments = [], sizes = new Map();
+        let adjustment = 0;
+        for (const entry of sorted) {
+            context.signal.throwIfAborted();
+            if (++work > maximum)
+                throw new SsconvertError("resource-limit", "ssconvert image metrics work limit exceeded");
+            const size = entry.sizePoints ?? fallback;
+            // Anchor fractions use nominal size even when traversal hides the cell.
+            sizes.set(entry.index, size);
+            adjustment += (entry.hidden ? 0 : size) - fallback;
+            indices.push(entry.index);
+            adjustments.push(adjustment);
+        }
+        return (index) => {
+            context.signal.throwIfAborted();
+            let left = 0, right = indices.length;
+            while (left < right) {
+                if (++work > maximum)
+                    throw new SsconvertError("resource-limit", "ssconvert image metrics work limit exceeded");
+                const middle = Math.floor((left + right) / 2);
+                if (indices[middle] < index)
+                    left = middle + 1;
+                else
+                    right = middle;
+            }
+            return { start: index * fallback + (left ? adjustments[left - 1] : 0), size: sizes.get(index) ?? fallback };
+        };
+    };
+    const columnDefault = sheet.view?.defaultColumnWidth, rowDefault = sheet.view?.defaultRowHeight;
+    return { column: axis(sheet.columns, typeof columnDefault === "number" ? columnDefault : 48),
+        row: axis(sheet.rows, typeof rowDefault === "number" ? rowDefault : 12.75) };
+}
+/** Owns graph filtering and native stable anchor order, not publication or filenames. */
+export function createImageRendering(options = {}) {
+    const producer = options.renderGraph, metrics = options.metrics;
+    return { async *exportGraphs(book, request, context) {
+            let work = 0;
+            const maximum = context.limits.workbookWork ?? context.limits.inputBytes + context.limits.cells * 32;
+            const charge = () => { context.signal.throwIfAborted(); if (++work > maximum)
+                throw new SsconvertError("resource-limit", "ssconvert graph work limit exceeded"); };
+            for (const sheet of book.sheets) {
+                context.signal.throwIfAborted();
+                if (request.canVisitSheet && !request.canVisitSheet(sheet.id)) {
+                    context.signal.throwIfAborted();
+                    return;
+                }
+                charge();
+                const positions = metrics?.(sheet, context) ?? sheetMetrics(sheet, context);
+                charge();
+                // Objects are prepended to the native sheet list. Stable GSList sorting
+                // preserves that reverse insertion order for anchors that compare equal.
+                const graphs = sheetObjects(sheet, context).filter(object => object.kind === "graph").reverse().map(object => {
+                    charge();
+                    const anchored = { ...object, anchor: { ...object.anchor,
+                            range: object.anchor.range ?? { startRow: 0, startColumn: 0, endRow: 1, endColumn: 1 },
+                            offsets: object.anchor.offsets.length ? object.anchor.offsets : [0, 0, 0, 0] } };
+                    const rectangle = objectRectangle(anchored, positions, context);
+                    return { object, rectangle, endpoints: [rectangle.y, rectangle.x, rectangle.y + rectangle.height, rectangle.x + rectangle.width] };
+                });
+                graphs.sort((a, b) => {
+                    charge();
+                    for (let index = 0; index < 4; index++) {
+                        const difference = a.endpoints[index] - b.endpoints[index];
+                        if (difference !== 0)
+                            return difference < 0 ? -1 : 1;
+                    }
+                    return 0;
+                });
+                for (const { object, rectangle } of graphs) {
+                    charge();
+                    const format = request.format ?? "svg";
+                    const descriptor = profileImageTargets.find(candidate => candidate.id === format);
+                    yield { uri: request.template, sheet: sheet.id, objectName: object.name,
+                        mediaType: descriptor?.mediaType ?? "application/octet-stream",
+                        async render() {
+                            charge();
+                            if (!descriptor) {
+                                if (format !== "unknown") {
+                                    await context.diagnostic?.({ code: "graph-image-format", severity: "warning",
+                                        message: `[GOImage::get_format_from_name] Unknown format name (${format})` });
+                                    charge();
+                                }
+                                throw new ImageExportError("Unknown image format");
+                            }
+                            if (!descriptor.graphRenderable) {
+                                await context.diagnostic?.({ code: "graph-image-format", severity: "warning",
+                                    message: "[GogRendererCairo:export_image] unsupported format" });
+                                charge();
+                                throw new ImageExportError("Unknown failure while saving image");
+                            }
+                            const background = producer ? undefined : graphBackground(object.graph);
+                            const width = Math.max(1, Math.min(Math.abs(rectangle.width), 32767 * 72 / request.resolution));
+                            const height = Math.max(1, Math.min(Math.abs(rectangle.height), 32767 * 72 / request.resolution));
+                            let pixelWidth = Math.trunc(width * request.resolution / 72), pixelHeight = Math.trunc(height * request.resolution / 72);
+                            // GOffice returns a 1x1 pixbuf when either Cairo dimension is zero.
+                            // Preserve the coupled fallback rather than clamping each axis.
+                            if (pixelWidth <= 0 || pixelHeight <= 0)
+                                pixelWidth = pixelHeight = 1;
+                            const rasterBytes = pixelWidth * pixelHeight * 4;
+                            const rasterTarget = ["png", "jpeg", "bmp", "ico", "tiff"].includes(format);
+                            if (rasterTarget && (!Number.isSafeInteger(rasterBytes) || rasterBytes > maximum))
+                                throw new SsconvertError("resource-limit", "ssconvert image raster work limit exceeded");
+                            let surface;
+                            if (producer)
+                                surface = await producer({ book, sheet, object, rectangle, width, height, resolution: request.resolution, format }, context);
+                            else {
+                                const rgba = rasterTarget ? new Uint8Array(rasterBytes) : undefined;
+                                if (rgba && background) {
+                                    const channels = [1, 3, 5].map(offset => Number.parseInt(background.slice(offset, offset + 2), 16));
+                                    for (let offset = 0; offset < rgba.length; offset += 4) {
+                                        if (offset % (pixelWidth * 4) === 0)
+                                            charge();
+                                        rgba[offset] = channels[0];
+                                        rgba[offset + 1] = channels[1];
+                                        rgba[offset + 2] = channels[2];
+                                        rgba[offset + 3] = 255;
+                                    }
+                                }
+                                surface = { width, height,
+                                    commands: background ? [{ kind: "rectangle", x: 0, y: 0, width, height, fill: background }] : [],
+                                    ...(rgba ? { raster: { width: pixelWidth, height: pixelHeight, rgba } } : {}) };
+                            }
+                            charge();
+                            return encodeGraphImage(surface, format, context);
+                        }
+                    };
+                }
+            }
+        } };
+}

package/dist/spreadsheet-engine/rendering/images/profile-raster.d.ts

@@ -0,0 +1,4 @@
+import { type CapabilityContext } from "../../contracts.js";
+import type { ImageSurface } from "./codecs.js";
+/** Real raster codecs for the captured GdkPixbuf writable plugin IDs. */
+export declare function encodeProfileRaster(image: NonNullable<ImageSurface["raster"]>, format: string, context: CapabilityContext): Uint8Array;

package/dist/spreadsheet-engine/rendering/images/profile-raster.js

@@ -0,0 +1,72 @@
+import { SsconvertError } from "../../contracts.js";
+import { ImageExportError } from "./formats.js";
+/** Real raster codecs for the captured GdkPixbuf writable plugin IDs. */
+export function encodeProfileRaster(image, format, context) {
+    const { width, height, rgba } = image;
+    if (format === "ico" && (width > 256 || height > 256))
+        throw new ImageExportError("Unknown failure while saving image");
+    const rowStride = format === "bmp" ? Math.ceil(width * 3 / 4) * 4 : format === "ico" ? width * 4 : width * 3;
+    const maskStride = format === "ico" ? Math.ceil(width / 32) * 4 : 0;
+    const offset = format === "bmp" ? 54 : format === "ico" ? 62 : 140;
+    const length = offset + (rowStride + maskStride) * height;
+    if (!Number.isSafeInteger(length) || length > context.limits.outputBytes)
+        throw new SsconvertError("resource-limit", "ssconvert image output bytes limit exceeded");
+    context.signal.throwIfAborted();
+    const bytes = new Uint8Array(length), view = new DataView(bytes.buffer);
+    if (format === "tiff") {
+        bytes.set([73, 73, 42, 0]);
+        view.setUint32(4, 8, true);
+        view.setUint16(8, 10, true);
+        const tags = [[256, 4, 1, width], [257, 4, 1, height], [258, 3, 3, 134], [259, 3, 1, 1],
+            [262, 3, 1, 2], [273, 4, 1, offset], [277, 3, 1, 3], [278, 4, 1, height],
+            [279, 4, 1, rowStride * height], [284, 3, 1, 1]];
+        for (const [index, tag] of tags.entries()) {
+            const position = 10 + index * 12;
+            view.setUint16(position, tag[0], true);
+            view.setUint16(position + 2, tag[1], true);
+            view.setUint32(position + 4, tag[2], true);
+            view.setUint32(position + 8, tag[3], true);
+        }
+        for (let index = 0; index < 3; index++)
+            view.setUint16(134 + index * 2, 8, true);
+    }
+    else {
+        const dib = format === "bmp" ? 14 : 22;
+        if (format === "bmp") {
+            bytes.set([66, 77]);
+            view.setUint32(2, length, true);
+            view.setUint32(10, offset, true);
+        }
+        else {
+            view.setUint16(2, 1, true);
+            view.setUint16(4, 1, true);
+            bytes[6] = width === 256 ? 0 : width;
+            bytes[7] = height === 256 ? 0 : height;
+            view.setUint16(10, 1, true);
+            view.setUint16(12, 32, true);
+            view.setUint32(14, length - 22, true);
+            view.setUint32(18, 22, true);
+        }
+        view.setUint32(dib, 40, true);
+        view.setInt32(dib + 4, width, true);
+        view.setInt32(dib + 8, format === "ico" ? height * 2 : height, true);
+        view.setUint16(dib + 12, 1, true);
+        view.setUint16(dib + 14, format === "bmp" ? 24 : 32, true);
+        view.setUint32(dib + 20, rowStride * height, true);
+    }
+    for (let y = 0; y < height; y++) {
+        context.signal.throwIfAborted();
+        for (let x = 0; x < width; x++) {
+            const source = (y * width + x) * 4;
+            const target = offset + (format === "tiff" ? y : height - y - 1) * rowStride + x * (format === "ico" ? 4 : 3);
+            const alpha = rgba[source + 3];
+            for (let channel = 0; channel < 3; channel++) {
+                const destination = format === "tiff" ? channel : 2 - channel;
+                bytes[target + destination] = Math.floor((rgba[source + channel] * alpha + 255 * (255 - alpha) + 127) / 255);
+            }
+            if (format === "ico")
+                bytes[target + 3] = 255;
+        }
+    }
+    return bytes;
+}

package/dist/spreadsheet-engine/rendering/images/scene.d.ts

@@ -0,0 +1,3 @@
+import type { ChartNode } from "../../objects/index.js";
+/** Resolved opaque root paint. Plot layout and text require their own renderer. */
+export declare function graphBackground(graph: ChartNode | undefined): string | undefined;

package/dist/spreadsheet-engine/rendering/images/scene.js

@@ -0,0 +1,34 @@
+import { SsconvertError } from "../../contracts.js";
+/** Resolved opaque root paint. Plot layout and text require their own renderer. */
+export function graphBackground(graph) {
+    const unsupported = () => { throw new SsconvertError("unsupported-feature", "Unsupported ssconvert feature: graph scene rendering"); };
+    if (!graph)
+        return undefined;
+    if (graph.type !== "GogGraph" || graph.children.length || graph.data.length)
+        return unsupported();
+    if (!graph.properties.length)
+        return undefined;
+    if (graph.properties.length !== 1 || graph.properties[0].attributes.name !== "style" || graph.properties[0].attributes.type !== "GogStyle")
+        return unsupported();
+    const style = graph.style;
+    // GogOutlinedView paints the root rectangle only. Font, marker and text
+    // layout metadata cannot paint anything without graph children or data.
+    if (!style || style.outline)
+        return unsupported();
+    if (style.line?.dash !== "none" || style.line["auto-dash"] !== "0")
+        return unsupported();
+    const fill = style.fill;
+    if (!fill || fill.attributes["auto-type"] !== "0")
+        return unsupported();
+    if (fill.attributes.type === "none")
+        return undefined;
+    if (fill.attributes.type !== "pattern" || fill.attributes["is-auto"] !== "0" || fill.gradient || fill.image || fill.pattern?.type !== "solid" || fill.pattern["auto-pattern"] !== "0")
+        return unsupported();
+    const components = fill.pattern.back?.split(":");
+    if (!components || components.length !== 4 || components.some(component => !component.length || component.length > 2 || !Array.from(component).every(char => "0123456789abcdefABCDEF".includes(char))))
+        return unsupported();
+    const channels = components.map(component => Number.parseInt(component, 16));
+    if (channels[3] !== 255)
+        return unsupported();
+    return "#" + channels.slice(0, 3).map(channel => channel.toString(16).padStart(2, "0")).join("");
+}

package/dist/spreadsheet-engine/rendering/print/cell-style.d.ts

@@ -0,0 +1,10 @@
+import type { ImportedValue } from "../../../spreadsheet-ast/index.js";
+export interface CellPrintStyle {
+    readonly alignment: "general" | "left" | "right" | "center";
+    readonly bold: boolean;
+    readonly size: number;
+    readonly foreground: readonly [number, number, number];
+    readonly background?: readonly [number, number, number];
+}
+/** Project the qualified Gnumeric style effects, refusing every unknown effect. */
+export declare function cellPrintStyle(style: Readonly<Record<string, ImportedValue>>, tick: (amount?: number) => void): CellPrintStyle;

package/dist/spreadsheet-engine/rendering/print/cell-style.js

@@ -0,0 +1,52 @@
+import { SsconvertError } from "../../contracts.js";
+const alignments = { GNM_HALIGN_GENERAL: "general", GNM_HALIGN_LEFT: "left", GNM_HALIGN_RIGHT: "right", GNM_HALIGN_CENTER: "center" };
+const styleDefaults = {
+    HAlign: Object.keys(alignments), VAlign: "GNM_VALIGN_BOTTOM", WrapText: "0", ShrinkToFit: "0",
+    Rotation: "0", Shade: ["0", "1"], Indent: "0", Locked: "1", Hidden: "0", Fore: ["0:0:0", "FFFF:0:0"],
+    Back: ["FFFF:FFFF:FFFF", "FFFF:FFFF:0"], PatternColor: "0:0:0", Format: "General"
+};
+const fontDefaults = { Unit: ["8", "10", "14"], Bold: ["0", "1"], Italic: "0", Underline: "0", StrikeThrough: "0", Script: "0" };
+/** Project the qualified Gnumeric style effects, refusing every unknown effect. */
+export function cellPrintStyle(style, tick) {
+    const fail = () => { throw new SsconvertError("unsupported-feature", "Unsupported ssconvert feature: PDF styled or merged cells"); };
+    const record = (value) => {
+        tick();
+        if (!value || typeof value !== "object" || Array.isArray(value))
+            fail();
+        return value;
+    };
+    const attributes = (node, expected) => {
+        if (!Array.isArray(node.attributes) || node.attributes.length !== Object.keys(expected).length)
+            fail();
+        const values = Object.create(null);
+        for (const value of node.attributes) {
+            const a = record(value);
+            if (a.namespace !== "" || typeof a.name !== "string" || typeof a.value !== "string")
+                fail();
+            const name = a.name, text = a.value;
+            tick(name.length + text.length);
+            const accepted = expected[name];
+            if (!Object.hasOwn(expected, name) || (typeof accepted === "string" ? accepted !== text : !accepted?.includes(text)) || Object.hasOwn(values, name))
+                fail();
+            values[name] = text;
+        }
+        return values;
+    };
+    tick();
+    if (Object.keys(style).length !== 1 || !Object.hasOwn(style, "gnumeric"))
+        fail();
+    const node = record(style.gnumeric);
+    if (node.name !== "Style" || node.namespace !== "http://www.gnumeric.org/v10.dtd" || typeof node.text !== "string")
+        fail();
+    tick(node.text.length);
+    if (node.text.trim() !== "" || !Array.isArray(node.children) || node.children.length !== 1)
+        fail();
+    const effects = attributes(node, styleDefaults);
+    const font = record(node.children[0]);
+    if (font.name !== "Font" || font.namespace !== "http://www.gnumeric.org/v10.dtd" || font.text !== "Sans" || !Array.isArray(font.children) || font.children.length)
+        fail();
+    const selected = attributes(font, fontDefaults);
+    return { alignment: alignments[effects.HAlign], bold: selected.Bold === "1", size: Number(selected.Unit),
+        foreground: effects.Fore === "FFFF:0:0" ? [1, 0, 0] : [0, 0, 0],
+        ...(effects.Shade === "1" ? { background: effects.Back === "FFFF:FFFF:0" ? [1, 1, 0] : [1, 1, 1] } : {}) };
+}

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

@@ -0,0 +1,43 @@
+/*!
+ * UNICODE LICENSE V3
+ *
+ * COPYRIGHT AND PERMISSION NOTICE
+ *
+ * Copyright © 1991-2026 Unicode, Inc.
+ *
+ * NOTICE TO USER: Carefully read the following legal agreement. BY
+ * DOWNLOADING, INSTALLING, COPYING OR OTHERWISE USING DATA FILES, AND/OR
+ * SOFTWARE, YOU UNEQUIVOCALLY ACCEPT, AND AGREE TO BE BOUND BY, ALL OF THE
+ * TERMS AND CONDITIONS OF THIS AGREEMENT. IF YOU DO NOT AGREE, DO NOT
+ * DOWNLOAD, INSTALL, COPY, DISTRIBUTE OR USE THE DATA FILES OR SOFTWARE.
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a
+ * copy of data files and any associated documentation (the "Data Files") or
+ * software and any associated documentation (the "Software") to deal in the
+ * Data Files or Software without restriction, including without limitation
+ * the rights to use, copy, modify, merge, publish, distribute, and/or sell
+ * copies of the Data Files or Software, and to permit persons to whom the
+ * Data Files or Software are furnished to do so, provided that either (a)
+ * this copyright and permission notice appear with all copies of the Data
+ * Files or Software, or (b) this copyright and permission notice appear in
+ * associated Documentation.
+ *
+ * THE DATA FILES AND SOFTWARE ARE PROVIDED "AS IS", WITHOUT WARRANTY OF ANY
+ * KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+ * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT OF
+ * THIRD PARTY RIGHTS.
+ *
+ * IN NO EVENT SHALL THE COPYRIGHT HOLDER OR HOLDERS INCLUDED IN THIS NOTICE
+ * BE LIABLE FOR ANY CLAIM, OR ANY SPECIAL INDIRECT OR CONSEQUENTIAL DAMAGES,
+ * OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS,
+ * WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION,
+ * ARISING OUT OF OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THE DATA
+ * FILES OR SOFTWARE.
+ *
+ * Except as contained in this notice, the name of a copyright holder shall
+ * not be used in advertising or otherwise to promote the sale, use or other
+ * dealings in these Data Files or Software without prior written
+ * authorization of the copyright holder.
+ */
+export declare const fontCharacterProperties: readonly (readonly [number, number, number, number])[];
+export declare const fontDecompositions: readonly (readonly [number, number, number, number])[];