@poe-platform/safe-bash 0.1.806 → 0.1.807

package/dist/spreadsheet-engine/rendering/print/header-footer.d.ts

@@ -0,0 +1,16 @@
+import { type CapabilityContext } from "../../contracts.js";
+export interface PrintHeaderFooterInfo {
+    readonly page: number;
+    readonly pages: number;
+    readonly sheetName: string;
+    readonly filename: string;
+    readonly path: string;
+    readonly title: string;
+    readonly timestamp?: {
+        readonly serial: number;
+        readonly dateSystem: "1900" | "1904";
+        format(serial: number, pattern: string, dateSystem: "1900" | "1904"): string;
+    };
+    cell?(reference: string, repeating: boolean): string;
+}
+export declare function renderPrintHeaderFooter(format: string, info: PrintHeaderFooterInfo, context: CapabilityContext): string;

package/dist/spreadsheet-engine/rendering/print/header-footer.js

@@ -0,0 +1,92 @@
+import { SsconvertError } from "../../contracts.js";
+import { printWork } from "./pagination.js";
+export function renderPrintHeaderFooter(format, info, context) {
+    const tick = printWork(context);
+    tick();
+    if (typeof format !== "string" || !Number.isSafeInteger(info.page) || !Number.isSafeInteger(info.pages) ||
+        info.page < 0 || info.pages < 0 || (context.limits.outputBytes !== Infinity && !Number.isSafeInteger(context.limits.outputBytes)) || context.limits.outputBytes < 0)
+        throw new SsconvertError("invalid-request", "Invalid ssconvert print header metadata");
+    let bytes = 0;
+    const parts = [];
+    function append(text) {
+        tick();
+        if (typeof text !== "string")
+            throw new SsconvertError("invalid-request", "Invalid ssconvert print header text");
+        // Count without first allocating an unbounded encoded copy of host text.
+        for (const character of text) {
+            tick();
+            if (character === "\0")
+                break;
+            const code = character.codePointAt(0);
+            bytes += code < 0x80 ? 1 : code < 0x800 ? 2 : code < 0x10000 ? 3 : 4;
+            if (bytes > context.limits.outputBytes)
+                throw new SsconvertError("resource-limit", "ssconvert print header output limit exceeded");
+        }
+        const end = text.indexOf("\0");
+        parts.push(end < 0 ? text : text.slice(0, end));
+    }
+    for (let index = 0; index < format.length;) {
+        tick();
+        if (format[index] === "\0")
+            break;
+        if (format[index] !== "&" || format[index + 1] !== "[") {
+            const code = format.codePointAt(index);
+            const count = code > 0xffff ? 2 : 1;
+            append(format.slice(index, index + count));
+            index += count;
+            continue;
+        }
+        const start = index + 2;
+        index = start;
+        while (index < format.length && format[index] !== "]" && format[index] !== "\0") {
+            tick();
+            index++;
+        }
+        if (index === format.length || format[index] === "\0")
+            break;
+        const operation = format.slice(start, index++);
+        const colon = operation.indexOf(":");
+        // These are the full Unicode casefold expansions that can occur in the
+        // English native opcode names. Lowercasing alone misses long s and fi.
+        const name = (colon < 0 ? operation : operation.slice(0, colon)).toLowerCase()
+            .replaceAll("ſ", "s").replaceAll("fi", "fi");
+        const args = colon < 0 ? undefined : operation.slice(colon + 1);
+        switch (name) {
+            case "tab":
+                append(info.sheetName);
+                break;
+            case "page":
+                append(String(info.page));
+                break;
+            case "pages":
+                append(String(info.pages));
+                break;
+            case "file":
+                append(info.filename);
+                break;
+            case "path":
+                append(info.path);
+                break;
+            case "title":
+                append(info.title);
+                break;
+            case "date":
+            case "time": {
+                const timestamp = info.timestamp;
+                if (!timestamp || !Number.isFinite(timestamp.serial) || !["1900", "1904"].includes(timestamp.dateSystem))
+                    throw new SsconvertError("invalid-request", "Missing or invalid ssconvert print timestamp metadata");
+                append(timestamp.format(timestamp.serial, args ?? (name === "date" ? "dd-mmm-yyyy" : "hh:mm"), timestamp.dateSystem));
+                break;
+            }
+            case "cell": {
+                if (!info.cell)
+                    throw new SsconvertError("invalid-request", "Missing ssconvert print cell metadata");
+                const repeating = args?.startsWith("rep|") ?? false;
+                append(info.cell(repeating ? args.slice(4) : args ?? "", repeating));
+                break;
+            }
+        }
+    }
+    tick();
+    return parts.join("");
+}

package/dist/spreadsheet-engine/rendering/print/layout.d.ts

@@ -0,0 +1,65 @@
+import { type CapabilityContext } from "../../contracts.js";
+import type { AxisMetadata, Range } from "../../../spreadsheet-ast/index.js";
+import { type AxisPrintPage, type PrintBreak } from "./pagination.js";
+export interface PrintLayoutRequest {
+    readonly area: Range;
+    readonly defaultRowPoints: number;
+    readonly defaultColumnPoints: number;
+    readonly rows?: readonly AxisMetadata[];
+    readonly columns?: readonly AxisMetadata[];
+    readonly repeatRows?: {
+        readonly start: number;
+        readonly end: number;
+    };
+    readonly repeatColumns?: {
+        readonly start: number;
+        readonly end: number;
+    };
+    readonly rowBreaks?: readonly PrintBreak[];
+    readonly columnBreaks?: readonly PrintBreak[];
+    /** Explicit paper data, including custom sizes; no ambient paper discovery. */
+    readonly paper: {
+        readonly widthPoints: number;
+        readonly heightPoints: number;
+    };
+    readonly orientation?: "portrait" | "landscape" | "reverse-portrait" | "reverse-landscape";
+    /** Top/bottom denote edges below the header and above the footer. */
+    readonly margins: {
+        readonly left: number;
+        readonly right: number;
+        readonly top: number;
+        readonly bottom: number;
+    };
+    readonly scale?: {
+        readonly kind: "percentage";
+        readonly x: number;
+        readonly y: number;
+    } | {
+        readonly kind: "fit";
+        readonly rows: number;
+        readonly columns: number;
+    };
+    readonly headings?: boolean;
+    readonly displayFormulas?: boolean;
+    readonly acrossThenDown?: boolean;
+    readonly centerHorizontally?: boolean;
+    readonly centerVertically?: boolean;
+    readonly startPage?: number;
+}
+export interface PrintPage {
+    readonly number: number;
+    readonly area: Range;
+    readonly rows: AxisPrintPage;
+    readonly columns: AxisPrintPage;
+    readonly originX: number;
+    readonly originY: number;
+}
+export interface PrintLayout {
+    readonly widthPoints: number;
+    readonly heightPoints: number;
+    readonly scaleX: number;
+    readonly scaleY: number;
+    readonly pages: readonly PrintPage[];
+}
+/** Pure page geometry from print.c compute_sheet_pages and print_page. */
+export declare function layoutPrintPages(request: PrintLayoutRequest, context: CapabilityContext): PrintLayout;

package/dist/spreadsheet-engine/rendering/print/layout.js

@@ -0,0 +1,75 @@
+import { SsconvertError } from "../../contracts.js";
+import { axisPaginator, printWork } from "./pagination.js";
+/** Pure page geometry from print.c compute_sheet_pages and print_page. */
+export function layoutPrintPages(request, context) {
+    const tick = printWork(context);
+    tick();
+    const landscape = request.orientation === "landscape" || request.orientation === "reverse-landscape";
+    if (request.orientation !== undefined && !["portrait", "landscape", "reverse-portrait", "reverse-landscape"].includes(request.orientation))
+        throw new SsconvertError("invalid-request", "Invalid ssconvert print orientation");
+    const widthPoints = landscape ? request.paper.heightPoints : request.paper.widthPoints;
+    const heightPoints = landscape ? request.paper.widthPoints : request.paper.heightPoints;
+    const margins = request.margins;
+    if (![widthPoints, heightPoints].every(value => Number.isFinite(value) && value > 0) ||
+        ![margins.left, margins.right, margins.top, margins.bottom].every(value => Number.isFinite(value) && value >= 0))
+        throw new SsconvertError("invalid-request", "Invalid ssconvert print paper geometry");
+    const usableX = widthPoints - margins.left - margins.right;
+    const usableY = heightPoints - margins.top - margins.bottom;
+    if (usableX <= 0 || usableY <= 0)
+        throw new SsconvertError("invalid-request", "Invalid ssconvert print margins");
+    const rowHeader = request.headings ? request.defaultColumnPoints : 0;
+    const columnHeader = request.headings ? request.defaultRowPoints : 0;
+    const rowAxis = axisPaginator({ start: request.area.startRow, end: request.area.endRow,
+        usablePoints: usableY, defaultSizePoints: request.defaultRowPoints,
+        ...(request.rows ? { items: request.rows } : {}),
+        ...(request.repeatRows ? { repeat: request.repeatRows } : {}),
+        ...(request.rowBreaks ? { breaks: request.rowBreaks } : {}) }, tick);
+    const columnAxis = axisPaginator({ start: request.area.startColumn, end: request.area.endColumn,
+        usablePoints: usableX, defaultSizePoints: request.defaultColumnPoints,
+        ...(request.columns ? { items: request.columns } : {}),
+        ...(request.repeatColumns ? { repeat: request.repeatColumns } : {}),
+        ...(request.columnBreaks ? { breaks: request.columnBreaks } : {}) }, tick);
+    let scaleX = 1, scaleY = 1;
+    if (request.scale?.kind === "fit") {
+        scaleY = rowAxis.fit(request.scale.rows, usableY, columnHeader);
+        scaleX = columnAxis.fit(request.scale.columns, usableX, rowHeader, scaleY);
+        scaleY = scaleX;
+    }
+    else if (request.scale?.kind === "percentage") {
+        if (![request.scale.x, request.scale.y].every(Number.isFinite))
+            throw new SsconvertError("invalid-request", "Invalid ssconvert print scale");
+        scaleX = request.scale.x / 100;
+        scaleY = request.scale.y / 100;
+    }
+    else if (request.scale !== undefined)
+        throw new SsconvertError("invalid-request", "Invalid ssconvert print scale type");
+    if (scaleX <= 0)
+        scaleX = 1;
+    if (scaleY <= 0)
+        scaleY = 1;
+    const formulaScale = request.displayFormulas ? 2 : 1;
+    const columns = columnAxis.paginate((usableX / scaleX - rowHeader) / formulaScale);
+    const rows = rowAxis.paginate(usableY / scaleY - columnHeader);
+    const count = columns.length * rows.length;
+    tick(count); // Admit the Cartesian product before its allocation.
+    if (request.startPage !== undefined && !Number.isSafeInteger(request.startPage))
+        throw new SsconvertError("invalid-request", "Invalid ssconvert print page number");
+    const startPage = request.startPage !== undefined && request.startPage >= 0 ? request.startPage : 1;
+    if (!Number.isSafeInteger(startPage) || !Number.isSafeInteger(startPage + count - 1))
+        throw new SsconvertError("invalid-request", "Invalid ssconvert print page number");
+    const pages = [];
+    for (let index = 0; index < count; index++) {
+        tick();
+        const rowIndex = request.acrossThenDown ? Math.floor(index / columns.length) : index % rows.length;
+        const columnIndex = request.acrossThenDown ? index % columns.length : Math.floor(index / rows.length);
+        const row = rows[rowIndex], column = columns[columnIndex];
+        const occupiedX = (column.sizePoints + column.repeatPoints + rowHeader) * scaleX;
+        const occupiedY = (row.sizePoints + row.repeatPoints + columnHeader) * scaleY;
+        pages.push({ number: startPage + index,
+            area: { startRow: row.start, endRow: row.end, startColumn: column.start, endColumn: column.end },
+            rows: row, columns: column,
+            originX: margins.left + (request.centerHorizontally ? (usableX - occupiedX) / 2 : 0),
+            originY: margins.top + (request.centerVertically ? (usableY - occupiedY) / 2 : 0) });
+    }
+    return { widthPoints, heightPoints, scaleX, scaleY, pages };
+}

package/dist/spreadsheet-engine/rendering/print/pagination.d.ts

@@ -0,0 +1,34 @@
+import { type CapabilityContext } from "../../contracts.js";
+import type { AxisMetadata } from "../../../spreadsheet-ast/index.js";
+export interface PrintBreak {
+    readonly position: number;
+    readonly type: "manual" | "auto" | "none" | "data-slice";
+}
+export interface AxisPrintRequest {
+    readonly start: number;
+    readonly end: number;
+    readonly usablePoints: number;
+    readonly defaultSizePoints: number;
+    readonly items?: readonly AxisMetadata[];
+    readonly repeat?: {
+        readonly start: number;
+        readonly end: number;
+    };
+    readonly breaks?: readonly PrintBreak[];
+}
+export interface AxisPrintPage {
+    readonly start: number;
+    readonly end: number;
+    readonly repeatStart: number;
+    readonly repeatCount: number;
+    readonly sizePoints: number;
+    readonly repeatPoints: number;
+}
+export declare function printWork(context: CapabilityContext): (amount?: number) => void;
+/** Gnumeric print.c compute_group/adjust_repetition/paginate; all sizes are points. */
+export declare function paginateAxis(request: AxisPrintRequest, context: CapabilityContext): readonly AxisPrintPage[];
+export declare function axisPaginator(request: AxisPrintRequest, tick: (amount?: number) => void): {
+    paginate: (usable: number) => readonly AxisPrintPage[];
+    fit: (pages: number, usable: number, header: number, maximum?: number) => number;
+    distance: (start: number, end: number) => number;
+};

package/dist/spreadsheet-engine/rendering/print/pagination.js

@@ -0,0 +1,126 @@
+import { SsconvertError } from "../../contracts.js";
+export function printWork(context) {
+    context.signal.throwIfAborted();
+    let work = 0;
+    const maximum = context.limits.workbookWork ?? context.limits.inputBytes * 8 + context.limits.cells * 32;
+    if ((maximum !== Infinity && !Number.isSafeInteger(maximum)) || maximum < 0)
+        throw new SsconvertError("invalid-request", "Invalid ssconvert print work budget");
+    return (amount = 1) => {
+        context.signal.throwIfAborted();
+        if (!Number.isSafeInteger(amount) || amount < 0)
+            throw new SsconvertError("invalid-request", "Invalid ssconvert print work amount");
+        if (amount > maximum - work)
+            throw new SsconvertError("resource-limit", "ssconvert print work limit exceeded");
+        work += amount;
+    };
+}
+/** Gnumeric print.c compute_group/adjust_repetition/paginate; all sizes are points. */
+export function paginateAxis(request, context) {
+    return axisPaginator(request, printWork(context)).paginate(request.usablePoints);
+}
+export function axisPaginator(request, tick) {
+    tick();
+    function index(value) {
+        if (!Number.isSafeInteger(value) || value < 0)
+            throw new SsconvertError("invalid-request", "Invalid ssconvert print axis index");
+    }
+    index(request.start);
+    index(request.end);
+    if (request.end < request.start || !Number.isFinite(request.usablePoints) ||
+        !Number.isFinite(request.defaultSizePoints) || request.defaultSizePoints < 0)
+        throw new SsconvertError("invalid-request", "Invalid ssconvert print axis geometry");
+    if (request.repeat) {
+        index(request.repeat.start);
+        index(request.repeat.end);
+        if (request.repeat.end < request.repeat.start)
+            throw new SsconvertError("invalid-request", "Reversed ssconvert print titles");
+    }
+    const sizes = new Map();
+    const hidden = new Set();
+    for (const item of request.items ?? []) {
+        tick();
+        index(item.index);
+        const points = item.sizePoints ?? request.defaultSizePoints;
+        if (!Number.isFinite(points) || points < 0 || sizes.has(item.index))
+            throw new SsconvertError("invalid-request", "Invalid ssconvert print axis metadata");
+        sizes.set(item.index, item.hidden ? 0 : points);
+        if (item.hidden)
+            hidden.add(item.index);
+    }
+    const breaks = new Set();
+    for (const entry of request.breaks ?? []) {
+        tick();
+        index(entry.position);
+        if (!["manual", "auto", "none", "data-slice"].includes(entry.type))
+            throw new SsconvertError("invalid-request", "Invalid ssconvert print page break");
+        if (entry.type === "manual" || entry.type === "data-slice")
+            breaks.add(entry.position);
+    }
+    function distance(start, end) {
+        let points = 0;
+        for (let i = start; i <= end; i++) {
+            tick();
+            points += sizes.get(i) ?? request.defaultSizePoints;
+        }
+        if (!Number.isFinite(points))
+            throw new SsconvertError("invalid-request", "Invalid ssconvert print axis extent");
+        return points;
+    }
+    function paginate(usable) {
+        tick();
+        const pages = [];
+        let start = request.start;
+        while (start <= request.end) {
+            tick();
+            const repeatStart = request.repeat && start > request.repeat.start ? request.repeat.start : 0;
+            const repeatCount = request.repeat && start > request.repeat.start ?
+                Math.min(start - request.repeat.start, request.repeat.end - request.repeat.start + 1) : 0;
+            const repeatPoints = distance(repeatStart, repeatStart + repeatCount - 1);
+            let end = start - 1, sizePoints = 0;
+            for (let i = start; i <= request.end; i++) {
+                tick();
+                if (i > start && breaks.has(i))
+                    break;
+                const size = sizes.get(i) ?? request.defaultSizePoints;
+                if (!hidden.has(i) && 1 + sizePoints + size > usable - repeatPoints && i > start)
+                    break;
+                sizePoints += size;
+                end = i;
+                if (!hidden.has(i) && 1 + sizePoints > usable - repeatPoints)
+                    break;
+            }
+            pages.push({ start, end, repeatStart, repeatCount, sizePoints, repeatPoints });
+            start = end + 1;
+        }
+        return pages;
+    }
+    /** Matches compute_scale_fit_to, including the single-page two-point allowance. */
+    function fit(pages, usable, header, maximum = 1) {
+        tick();
+        if (!Number.isSafeInteger(pages) || pages < 0 || !Number.isFinite(usable) || usable <= 0 ||
+            !Number.isFinite(header) || header < 0 || !Number.isFinite(maximum) || maximum <= 0)
+            throw new SsconvertError("invalid-request", "Invalid ssconvert print fit geometry");
+        if (pages === 0)
+            return maximum;
+        let extent = distance(request.start, request.end);
+        if (request.repeat && request.repeat.start < request.start)
+            extent += distance(request.repeat.start, Math.min(request.repeat.end, request.start - 1));
+        if (pages === 1)
+            return Math.min(maximum, usable / (header + extent + 2));
+        const clamp = (value) => Math.min(maximum, Math.max(0.01, value));
+        let high = clamp(pages * usable / (extent + pages * header));
+        if (paginate(usable / high - header).length === pages)
+            return high;
+        let low = clamp(usable / (extent + header));
+        while (high - low > 0.001) {
+            tick();
+            const middle = (high + low) / 2;
+            if (paginate(usable / middle - header).length > pages)
+                high = middle;
+            else
+                low = middle;
+        }
+        return low;
+    }
+    return { paginate, fit, distance };
+}

package/dist/spreadsheet-engine/rendering/print/settings.d.ts

@@ -0,0 +1,42 @@
+import { type CapabilityContext } from "../../contracts.js";
+import type { Sheet } from "../../../spreadsheet-ast/index.js";
+import { type PrintBreak } from "./pagination.js";
+/** Project retained Gnumeric print settings without consulting host preferences. */
+export declare function sheetPrintSettings(sheet: Sheet, context: CapabilityContext): {
+    firstPageNumber: number | undefined;
+    rowBreaks: PrintBreak[];
+    columnBreaks: PrintBreak[];
+    margins: {
+        top: number;
+        bottom: number;
+        left: number;
+        right: number;
+    };
+    headerPoints: number;
+    footerPoints: number;
+    header: {
+        Left: string;
+        Middle: string;
+        Right: string;
+    };
+    footer: {
+        Left: string;
+        Middle: string;
+        Right: string;
+    };
+    paper: string | undefined;
+    orientation: "portrait" | "landscape";
+    scale: {
+        readonly kind: "percentage";
+        readonly x: number;
+        readonly y: number;
+    } | {
+        readonly kind: "fit";
+        readonly rows: number;
+        readonly columns: number;
+    };
+    centerHorizontally: boolean;
+    centerVertically: boolean;
+    acrossThenDown: boolean;
+    doNotPrint: boolean;
+};

package/dist/spreadsheet-engine/rendering/print/settings.js

@@ -0,0 +1,159 @@
+import { SsconvertError } from "../../contracts.js";
+import { printWork } from "./pagination.js";
+/** Project retained Gnumeric print settings without consulting host preferences. */
+export function sheetPrintSettings(sheet, context) {
+    const tick = printWork(context);
+    const unsupported = (name) => { throw new SsconvertError("unsupported-feature", `Unsupported ssconvert feature: PDF print ${name}`); };
+    const record = (value) => value !== null && typeof value === "object" && !Array.isArray(value) ? value : undefined;
+    const project = (value, depth = 0) => {
+        tick();
+        if (depth > 16)
+            unsupported("settings depth");
+        const data = record(value);
+        if (!data || data.namespace !== "http://www.gnumeric.org/v10.dtd" || typeof data.name !== "string" || typeof data.text !== "string")
+            return undefined;
+        tick(data.name.length + data.text.length);
+        const attributes = Object.create(null);
+        for (const value of Array.isArray(data.attributes) ? data.attributes : []) {
+            tick();
+            const attribute = record(value);
+            if (attribute?.namespace === "" && typeof attribute.name === "string" && typeof attribute.value === "string") {
+                tick(attribute.name.length + attribute.value.length);
+                attributes[attribute.name] = attribute.value;
+            }
+        }
+        const children = [];
+        for (const value of Array.isArray(data.children) ? data.children : []) {
+            const child = project(value, depth + 1);
+            if (child)
+                children.push(child);
+        }
+        return { name: data.name, text: data.text, attributes, children };
+    };
+    const margins = { top: 120, bottom: 120, left: 72, right: 72 };
+    let firstPageNumber;
+    let headerPoints = 72, footerPoints = 72, paper;
+    let orientation = "portrait";
+    let scale = { kind: "percentage", x: 100, y: 100 };
+    let rowBreaks = [], columnBreaks = [];
+    let centerHorizontally = false, centerVertically = false, acrossThenDown = false, doNotPrint = false;
+    const header = { Left: "", Middle: "&[TAB]", Right: "" }, footer = { Left: "", Middle: "Page &[PAGE]", Right: "" };
+    for (const retained of sheet.unsupportedRecords ?? []) {
+        tick();
+        if (retained.kind !== "PrintInformation")
+            continue;
+        const root = project(retained.data);
+        if (!root || root.name !== "PrintInformation")
+            return unsupported("settings representation");
+        for (const node of root.children) {
+            tick();
+            const a = node.attributes;
+            const number = (key, fallback) => {
+                const value = a[key] === undefined || a[key].trim() === "" ? fallback : Number(a[key]);
+                if (!Number.isFinite(value))
+                    unsupported(`invalid ${node.name}`);
+                return value;
+            };
+            if (node.name === "Margins") {
+                for (const margin of node.children) {
+                    tick();
+                    const value = Number(margin.attributes.Points);
+                    if (margin.attributes.Points === undefined || !Number.isFinite(value) || value < 0)
+                        continue;
+                    if (Object.hasOwn(margins, margin.name))
+                        margins[margin.name] = value;
+                    else if (margin.name === "header")
+                        headerPoints = value;
+                    else if (margin.name === "footer")
+                        footerPoints = value;
+                }
+            }
+            else if (node.name === "first_page_number") {
+                const value = number("value", 0);
+                if (!Number.isInteger(value) || value < 0 || value > 0xffffffff)
+                    unsupported("invalid first page number");
+                firstPageNumber = value;
+            }
+            else if (node.name === "paper")
+                paper = node.text;
+            else if (node.name === "orientation")
+                orientation = node.text === "landscape" ? "landscape" : "portrait";
+            else if (node.name === "Scale") {
+                if (a.type === "percentage") {
+                    const value = number("percentage", 100);
+                    scale = { kind: "percentage", x: value, y: value };
+                }
+                else
+                    scale = { kind: "fit", columns: number("cols", 1), rows: number("rows", 1) };
+            }
+            else if (node.name === "hcenter")
+                centerHorizontally = number("value", 0) === 1;
+            else if (node.name === "vcenter")
+                centerVertically = number("value", 0) === 1;
+            else if (node.name === "order")
+                acrossThenDown = node.text === "r_then_d";
+            else if (node.name === "do_not_print")
+                doNotPrint = number("value", 0) !== 0;
+            else if (node.name === "Header" || node.name === "Footer") {
+                const target = node.name === "Header" ? header : footer;
+                for (const key of ["Left", "Middle", "Right"])
+                    if (a[key] !== undefined)
+                        target[key] = a[key];
+            }
+            else if (["grid", "titles", "monochrome", "even_if_only_styles", "draft"].includes(node.name)) {
+                if (number("value", 0))
+                    unsupported(node.name);
+            }
+            else if (node.name === "repeat_top" || node.name === "repeat_left") {
+                if (a.value)
+                    unsupported(node.name);
+            }
+            else if (node.name === "vPageBreaks" || node.name === "hPageBreaks") {
+                const breaks = [];
+                let previous = -1;
+                for (const child of node.children) {
+                    tick();
+                    if (child.name !== "break" || child.attributes.pos === undefined)
+                        continue;
+                    const raw = child.attributes.pos;
+                    tick(raw.length);
+                    let start = 0;
+                    while (start < raw.length && " \t\n\r\v\f".includes(raw[start]))
+                        start++;
+                    if (raw[start] === "+" || raw[start] === "-")
+                        start++;
+                    if (start === raw.length && raw.length)
+                        continue;
+                    if ([...raw.slice(start)].some(char => char < "0" || char > "9"))
+                        continue;
+                    const position = Number(raw);
+                    if (!Number.isInteger(position) || position < 0 || position > 2147483647)
+                        continue;
+                    const value = (child.attributes.type ?? "none").toLowerCase();
+                    const type = value === "manual" || value === "auto" || value === "data-slice" ? value : "none";
+                    if (type === "none" || position <= previous)
+                        continue;
+                    previous = position;
+                    // Native appends in ascending order before cleaning automatic breaks.
+                    if (type !== "auto")
+                        breaks.push({ position, type });
+                }
+                if (node.name === "hPageBreaks")
+                    rowBreaks = breaks;
+                else
+                    columnBreaks = breaks;
+            }
+            else if (node.name === "comments") {
+                if (a.placement && a.placement !== "GNM_PRINT_COMMENTS_IN_PLACE")
+                    unsupported("comments");
+            }
+            else if (node.name === "errors") {
+                if (a.PrintErrorsAs && a.PrintErrorsAs !== "GNM_PRINT_ERRORS_AS_DISPLAYED")
+                    unsupported("errors");
+            }
+            else if (!["PrintUnit", "print_range", "print-to-uri"].includes(node.name))
+                unsupported(node.name);
+        }
+    }
+    return { firstPageNumber, rowBreaks, columnBreaks, margins, headerPoints, footerPoints, header, footer, paper, orientation, scale, centerHorizontally, centerVertically, acrossThenDown, doNotPrint };
+}

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

@@ -148,18 +148,18 @@ export function readBiffMetadata(records, revision, codepage, context) {
         }
         else if (opcode === 0x81) {
             const flags = data.u16(0);
-            view.gnumeric = { OutlineSymbolsBelow: flags & 0x40 ? "1" : "0", OutlineSymbolsRight: flags & 0x80 ? "1" : "0" };
+            view.gnumeric = { ...view.gnumeric, OutlineSymbolsBelow: flags & 0x40 ? "1" : "0", OutlineSymbolsRight: flags & 0x80 ? "1" : "0" };
             fitToPage = !!(flags & 0x100);
         }
         else if (opcode === 0x23e) {
             const flags = data.u16(0);
-            active = !!(flags & 0x200);
+            active = !!(flags & 0x400);
             window = { row: data.u16(2), column: data.u16(4), frozen: !!(flags & 8) };
             if (window.column > 255 || window.row >= (revision >= 8 ? 65536 : 16384))
                 invalidBiff("invalid sheet layout position");
             view.gnumeric = { ...view.gnumeric, DisplayFormulas: flags & 1 ? "1" : "0",
                 HideGrid: flags & 2 ? "0" : "1", HideColHeader: flags & 4 ? "0" : "1", HideRowHeader: flags & 4 ? "0" : "1",
-                HideZero: flags & 0x10 ? "0" : "1", DisplayOutlines: flags & 0x80 ? "1" : "0" };
+                HideZero: flags & 0x10 ? "0" : "1", RTL_Layout: flags & 0x40 ? "1" : "0", DisplayOutlines: flags & 0x80 ? "1" : "0" };
             if (revision >= 8 && data.bytes.length >= 14)
                 view.zoom = data.u16(12) ? data.u16(12) / 100 : 1;
         }

package/dist/spreadsheet-format-xls/biff-write-metadata.d.ts

@@ -14,7 +14,7 @@ export declare class BiffMetadataWriter {
     prepare(): Promise<void>;
     loss(bytes: Uint8Array, sheet?: Sheet): Promise<void>;
     global(output: BiffOutput): void;
-    view(output: BiffOutput, sheet: Sheet, revision: 7 | 8, active: boolean): void;
+    view(output: BiffOutput, sheet: Sheet, revision: 7 | 8, active: boolean): Promise<void>;
     sheet(output: BiffOutput, sheet: Sheet, revision: 7 | 8): Promise<void>;
     links(output: BiffOutput, sheet: Sheet, revision: 7 | 8): Promise<void>;
     private legacyComments;