@grafloria/element 0.3.18 → 0.3.20

package/src/libs/renderer/src/export/pagination.d.ts

@@ -0,0 +1,116 @@
+import type { VNode } from '../types/vnode.types';
+import type { Rectangle } from '../types/geometry.types';
+export interface Page {
+    /** 0-based, reading order (left→right, top→bottom). */
+    index: number;
+    row: number;
+    column: number;
+    /** The world window mapped onto the paper. Always the full page size — see the header. */
+    rect: Rectangle;
+    /** The sub-rectangle actually painted. Equals `rect` unless a break was snapped in. */
+    clip: Rectangle;
+}
+export interface PaginationOptions {
+    /** One page's width in WORLD units. */
+    pageWidth: number;
+    /** One page's height in WORLD units. */
+    pageHeight: number;
+    /**
+     * World units each page repeats from its neighbour — a bleed, so a printed poster can be
+     * trimmed and taped without losing a strip. Default 0.
+     */
+    overlap?: number;
+    /**
+     * Pull a page break back so it does not slice through a node. Default true — a break
+     * through the middle of a box is the thing that makes tiled printouts unusable.
+     */
+    snapToNodes?: boolean;
+    /**
+     * How far a break may be pulled back, as a fraction of the page. Default 0.25.
+     *
+     * A break is only worth moving if the page it leaves behind is still mostly full: pulling
+     * a break back by 90% to spare one node would turn a 4-page print into a 9-page one. Past
+     * this limit we accept the cut.
+     */
+    snapTolerance?: number;
+    /** The region to paginate. Default: the tree's content bounds. */
+    content?: Rectangle;
+    /** Padding around the content bounds, in world units. Default 20. */
+    padding?: number;
+}
+export interface PaginationResult {
+    pages: Page[];
+    columns: number;
+    rows: number;
+    /** The x break positions (page origins). */
+    columnBreaks: number[];
+    /** The y break positions. */
+    rowBreaks: number[];
+    /** Nodes we could NOT spare — a break had to cut them. */
+    warnings: string[];
+}
+/** A node's world box — what a break must avoid slicing. */
+interface Box {
+    min: number;
+    max: number;
+}
+/**
+ * Collect the world boxes of the diagram's NODES.
+ *
+ * Nodes only. Links are lines: cutting one across a page boundary is normal and reads fine
+ * (the line simply continues on the next tile). Cutting a NODE leaves half a box and half a
+ * word, which is what makes a tiled print look broken.
+ */
+export declare function nodeBoxes(root: VNode): Array<{
+    x: Box;
+    y: Box;
+}>;
+/**
+ * Choose the break positions along ONE axis.
+ *
+ * Walks left to right. At each naive break (`origin + pageSize`) it looks for boxes the
+ * break would slice; if there are any, it tries pulling the break back to the leftmost
+ * slicee's leading edge. That move is only taken when the page it leaves is still at least
+ * `1 - tolerance` full — otherwise we would trade one cut node for a page count explosion.
+ */
+export declare function computeBreaks(start: number, end: number, pageSize: number, boxes: Box[], options: {
+    snap: boolean;
+    tolerance: number;
+    overlap: number;
+    warnings: string[];
+    axis: 'x' | 'y';
+}): number[];
+/**
+ * Lay a diagram out across a grid of pages.
+ */
+export declare function paginate(root: VNode, options: PaginationOptions): PaginationResult;
+export interface PrintOptions {
+    /** Shown in the browser's print dialog and as the default filename. */
+    title?: string;
+    /** CSS page size, e.g. `'A4 landscape'`. Default `'auto'`. */
+    pageSize?: string;
+    /** CSS margin for @page. Default `'10mm'`. */
+    margin?: string;
+}
+/**
+ * Build a printable HTML document from already-exported SVG pages.
+ *
+ * PURE — it returns a string. That is deliberate: it keeps the page-building testable, and
+ * leaves the one genuinely browser-side act (opening a print dialog) to `printDocument`.
+ *
+ * The `page-break-after` on every sheet but the last is what makes the browser emit one
+ * physical page per tile instead of reflowing them all into a single column.
+ */
+export declare function buildPrintDocument(svgPages: string[], options?: PrintOptions): string;
+/**
+ * Open the browser's print dialog for a document built by {@link buildPrintDocument}.
+ *
+ * Prints through a hidden IFRAME rather than `window.open`: a popup is blocked by default in
+ * every browser unless the call is inside a user gesture, and a blocked popup means the
+ * print button silently does nothing. An iframe always works, and it does not disturb the
+ * page the user is on.
+ *
+ * Browser-only, and it says so rather than throwing something cryptic in Node.
+ */
+export declare function printDocument(html: string): Promise<void>;
+export {};

package/src/libs/renderer/src/export/pagination.js

@@ -0,0 +1,245 @@
+"use strict";
+// Multi-page pagination + print (Card 5).
+//
+// Slice a diagram too big for one sheet into a grid of pages — and put the breaks where
+// they do not cut a node in half.
+//
+// THE GEOMETRY THAT MATTERS
+// -------------------------
+// A page has TWO rectangles, and conflating them is the bug this design exists to avoid:
+//
+//   rect   the world WINDOW mapped onto the paper. ALWAYS pageWidth × pageHeight, on
+//          every page, so every page renders at the SAME SCALE. (Give pages variable
+//          widths and each one fits-to-page at a different zoom — a printed poster whose
+//          tiles do not line up.)
+//   clip   what is actually PAINTED. Shrinks when a break has been pulled in to spare a
+//          node, leaving white space at the page's edge instead of a sliced-in-half box.
+//
+// So snapping only ever moves a break EARLIER, never later: a page can paint less than its
+// window, but it can never need to paint more than the paper holds.
+//
+// Pure and deterministic. `print()` at the bottom is the one browser-only function, and it
+// touches `document` inside the call, never at module scope — the node-environment test
+// imports this module and must not blow up.
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.nodeBoxes = nodeBoxes;
+exports.computeBreaks = computeBreaks;
+exports.paginate = paginate;
+exports.buildPrintDocument = buildPrintDocument;
+exports.printDocument = printDocument;
+const bounds_1 = require("./bounds");
+/**
+ * Collect the world boxes of the diagram's NODES.
+ *
+ * Nodes only. Links are lines: cutting one across a page boundary is normal and reads fine
+ * (the line simply continues on the next tile). Cutting a NODE leaves half a box and half a
+ * word, which is what makes a tiled print look broken.
+ */
+function nodeBoxes(root) {
+    const out = [];
+    const walk = (vnode) => {
+        var _a;
+        if (!vnode || typeof vnode !== 'object')
+            return;
+        if (typeof vnode.key === 'string' && /^node-/.test(vnode.key)) {
+            const bounds = (0, bounds_1.vnodeBounds)(vnode);
+            if (bounds && bounds.width > 0 && bounds.height > 0) {
+                out.push({
+                    x: { min: bounds.x, max: bounds.x + bounds.width },
+                    y: { min: bounds.y, max: bounds.y + bounds.height },
+                });
+            }
+            return; // a node's subtree is the node; do not recurse into it
+        }
+        for (const child of (_a = vnode.children) !== null && _a !== void 0 ? _a : [])
+            walk(child);
+    };
+    walk(root);
+    return out;
+}
+/**
+ * Choose the break positions along ONE axis.
+ *
+ * Walks left to right. At each naive break (`origin + pageSize`) it looks for boxes the
+ * break would slice; if there are any, it tries pulling the break back to the leftmost
+ * slicee's leading edge. That move is only taken when the page it leaves is still at least
+ * `1 - tolerance` full — otherwise we would trade one cut node for a page count explosion.
+ */
+function computeBreaks(start, end, pageSize, boxes, options) {
+    const breaks = [start];
+    if (pageSize <= 0)
+        return breaks;
+    let origin = start;
+    let guard = 0;
+    while (origin + pageSize < end) {
+        // Runaway guard: a snap that never advances would spin forever. Cannot happen given the
+        // minimum-advance rule below, but a paginator that hangs the UI is not a risk worth taking.
+        if (++guard > 10000)
+            break;
+        const naive = origin + pageSize;
+        let next = naive;
+        if (options.snap) {
+            const sliced = boxes.filter(box => box.min < naive - 1e-6 && box.max > naive + 1e-6);
+            if (sliced.length > 0) {
+                const leftmost = Math.min(...sliced.map(box => box.min));
+                // The page must still be at least (1 - tolerance) full for the move to be worth it.
+                const minAdvance = origin + pageSize * (1 - options.tolerance);
+                if (leftmost > minAdvance) {
+                    next = leftmost;
+                }
+                else {
+                    // We are cutting something. Say so — a silent slice through a node is the exact
+                    // failure this option exists to prevent, so it must not fail quietly.
+                    const stillSliced = boxes.filter(box => box.min < next - 1e-6 && box.max > next + 1e-6);
+                    if (stillSliced.length > 0) {
+                        options.warnings.push(`a page break on ${options.axis} at ${Math.round(next)} cuts through ${stillSliced.length} ` +
+                            `node(s) — the node is wider than the tolerance allows the break to move ` +
+                            `(raise snapTolerance, or use a larger page).`);
+                    }
+                }
+            }
+        }
+        // The next page starts `overlap` earlier, so the tiles share a strip.
+        origin = Math.max(next - options.overlap, origin + pageSize * 0.05);
+        breaks.push(origin);
+    }
+    return breaks;
+}
+/**
+ * Lay a diagram out across a grid of pages.
+ */
+function paginate(root, options) {
+    var _a, _b, _c, _d;
+    const warnings = [];
+    const padding = (_a = options.padding) !== null && _a !== void 0 ? _a : 20;
+    const bounds = (_b = options.content) !== null && _b !== void 0 ? _b : (() => {
+        const box = (0, bounds_1.vnodeBounds)(root);
+        if (!box)
+            return { x: 0, y: 0, width: 1, height: 1 };
+        return { x: box.x - padding, y: box.y - padding, width: box.width + padding * 2, height: box.height + padding * 2 };
+    })();
+    const snap = options.snapToNodes !== false;
+    const tolerance = Math.max(0, Math.min(0.9, (_c = options.snapTolerance) !== null && _c !== void 0 ? _c : 0.25));
+    const overlap = Math.max(0, (_d = options.overlap) !== null && _d !== void 0 ? _d : 0);
+    const boxes = snap ? nodeBoxes(root) : [];
+    const columnBreaks = computeBreaks(bounds.x, bounds.x + bounds.width, options.pageWidth, boxes.map(b => b.x), { snap, tolerance, overlap, warnings, axis: 'x' });
+    const rowBreaks = computeBreaks(bounds.y, bounds.y + bounds.height, options.pageHeight, boxes.map(b => b.y), { snap, tolerance, overlap, warnings, axis: 'y' });
+    const contentRight = bounds.x + bounds.width;
+    const contentBottom = bounds.y + bounds.height;
+    const pages = [];
+    let index = 0;
+    for (let row = 0; row < rowBreaks.length; row++) {
+        for (let column = 0; column < columnBreaks.length; column++) {
+            const x = columnBreaks[column];
+            const y = rowBreaks[row];
+            // The WINDOW is always a full page — every page therefore renders at the same scale.
+            const rect = { x, y, width: options.pageWidth, height: options.pageHeight };
+            // The CLIP stops at the next break (or the content edge), so a break pulled back to
+            // spare a node leaves white space rather than half a box.
+            const clipRight = column + 1 < columnBreaks.length ? columnBreaks[column + 1] + overlap : contentRight;
+            const clipBottom = row + 1 < rowBreaks.length ? rowBreaks[row + 1] + overlap : contentBottom;
+            const clip = {
+                x,
+                y,
+                width: Math.max(0, Math.min(clipRight, x + options.pageWidth) - x),
+                height: Math.max(0, Math.min(clipBottom, y + options.pageHeight) - y),
+            };
+            pages.push({ index: index++, row, column, rect, clip });
+        }
+    }
+    return {
+        pages,
+        columns: columnBreaks.length,
+        rows: rowBreaks.length,
+        columnBreaks,
+        rowBreaks,
+        warnings: [...new Set(warnings)],
+    };
+}
+/**
+ * Build a printable HTML document from already-exported SVG pages.
+ *
+ * PURE — it returns a string. That is deliberate: it keeps the page-building testable, and
+ * leaves the one genuinely browser-side act (opening a print dialog) to `printDocument`.
+ *
+ * The `page-break-after` on every sheet but the last is what makes the browser emit one
+ * physical page per tile instead of reflowing them all into a single column.
+ */
+function buildPrintDocument(svgPages, options = {}) {
+    var _a, _b, _c;
+    const title = escapeHtml((_a = options.title) !== null && _a !== void 0 ? _a : 'Diagram');
+    const size = (_b = options.pageSize) !== null && _b !== void 0 ? _b : 'auto';
+    const margin = (_c = options.margin) !== null && _c !== void 0 ? _c : '10mm';
+    const sheets = svgPages
+        .map((svg, index) => `<section class="sheet${index === svgPages.length - 1 ? ' last' : ''}">${svg}</section>`)
+        .join('');
+    return (`<!DOCTYPE html><html><head><meta charset="utf-8"><title>${title}</title><style>` +
+        `@page { size: ${size}; margin: ${margin}; }` +
+        `* { box-sizing: border-box; }` +
+        `html, body { margin: 0; padding: 0; }` +
+        `.sheet { page-break-after: always; break-after: page; display: flex; align-items: center; justify-content: center; }` +
+        // The LAST sheet must not force a break, or every print gets a trailing blank page.
+        `.sheet.last { page-break-after: auto; break-after: auto; }` +
+        `.sheet svg { max-width: 100%; max-height: 100%; height: auto; }` +
+        `@media print { .sheet { width: 100%; height: 100vh; } }` +
+        `</style></head><body>${sheets}</body></html>`);
+}
+function escapeHtml(value) {
+    return value
+        .replace(/&/g, '&amp;')
+        .replace(/</g, '&lt;')
+        .replace(/>/g, '&gt;')
+        .replace(/"/g, '&quot;');
+}
+/**
+ * Open the browser's print dialog for a document built by {@link buildPrintDocument}.
+ *
+ * Prints through a hidden IFRAME rather than `window.open`: a popup is blocked by default in
+ * every browser unless the call is inside a user gesture, and a blocked popup means the
+ * print button silently does nothing. An iframe always works, and it does not disturb the
+ * page the user is on.
+ *
+ * Browser-only, and it says so rather than throwing something cryptic in Node.
+ */
+function printDocument(html) {
+    const globalAny = globalThis;
+    const doc = globalAny.document;
+    if (!doc) {
+        return Promise.reject(new Error('[grafloria/export] printDocument needs a browser. In Node, export a PDF instead — export("pdf").'));
+    }
+    return new Promise(resolve => {
+        var _a, _b;
+        const frame = doc.createElement('iframe');
+        frame.setAttribute('aria-hidden', 'true');
+        frame.style.position = 'fixed';
+        frame.style.right = '0';
+        frame.style.bottom = '0';
+        frame.style.width = '0';
+        frame.style.height = '0';
+        frame.style.border = '0';
+        frame.onload = () => {
+            const view = frame.contentWindow;
+            if (view) {
+                view.focus();
+                view.print();
+            }
+            // Give the print dialog time to take its snapshot before the frame is torn down —
+            // removing it synchronously cancels the print in Safari.
+            globalAny.setTimeout(() => {
+                frame.remove();
+                resolve();
+            }, 1000);
+        };
+        doc.body.appendChild(frame);
+        const frameDoc = (_a = frame.contentDocument) !== null && _a !== void 0 ? _a : (_b = frame.contentWindow) === null || _b === void 0 ? void 0 : _b.document;
+        if (!frameDoc) {
+            frame.remove();
+            resolve();
+            return;
+        }
+        frameDoc.open();
+        frameDoc.write(html);
+        frameDoc.close();
+    });
+}
+//# sourceMappingURL=pagination.js.map

package/src/libs/renderer/src/export/pdf/flate.d.ts

@@ -0,0 +1,13 @@
+/** adler32 (RFC 1950) — the checksum a zlib stream ends with. */
+export declare function adler32(data: Uint8Array): number;
+/** Inflate a raw RFC 1951 stream. Throws on malformed data — wrong pixels are worse than no pixels. */
+export declare function inflateRaw(data: Uint8Array): Uint8Array;
+/** Inflate an RFC 1950 (zlib) stream — the wrapper a PNG IDAT uses. */
+export declare function zlibInflate(data: Uint8Array): Uint8Array;
+/**
+ * Wrap raw bytes as a valid zlib stream using STORED (uncompressed) deflate blocks.
+ *
+ * Every PDF reader's /FlateDecode accepts this — stored blocks are ordinary deflate.
+ * See the header for why we do not compress.
+ */
+export declare function zlibDeflateStored(data: Uint8Array): Uint8Array;

package/src/libs/renderer/src/export/pdf/flate.js

@@ -0,0 +1,287 @@
+"use strict";
+// A small, dependency-free DEFLATE pair: RFC 1951 inflate in, stored-block zlib out.
+//
+// WHY NOT fflate: it IS in node_modules — but only as a transitive dependency of
+// `@tokenizer/inflate` (checked in package-lock.json; it appears in no dependency list of
+// this workspace). Importing a package we do not declare works until the package that
+// does declare it bumps a version, and then the renderer build breaks for a reason
+// nobody can see in our package.json. The PDF exporter's whole design is
+// dependency-free (see pdf-export.ts's header); ~200 lines of RFC 1951 keeps it that way.
+//
+// WHY ONLY STORED BLOCKS ON THE WAY OUT: writing a real compressor (LZ77 + Huffman)
+// is an order of magnitude more code and bug surface than reading one, and correctness
+// beats size here — a stored-block stream is still a 100% valid /FlateDecode stream that
+// every PDF reader inflates. The cost is honest: a split RGBA image embeds at raw size.
+//
+// Everything here is pure (Uint8Array in, Uint8Array out), synchronous, DOM-free and
+// deterministic — the properties the exporter guarantees.
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.adler32 = adler32;
+exports.inflateRaw = inflateRaw;
+exports.zlibInflate = zlibInflate;
+exports.zlibDeflateStored = zlibDeflateStored;
+/** adler32 (RFC 1950) — the checksum a zlib stream ends with. */
+function adler32(data) {
+    // 65521 is the largest prime < 2^16; 5552 is the standard NMAX (largest n such that
+    // the sums cannot overflow 32 bits before folding).
+    let a = 1;
+    let b = 0;
+    let i = 0;
+    while (i < data.length) {
+        const end = Math.min(i + 5552, data.length);
+        for (; i < end; i++) {
+            a += data[i];
+            b += a;
+        }
+        a %= 65521;
+        b %= 65521;
+    }
+    return ((b << 16) | a) >>> 0;
+}
+// ---------------------------------------------------------------------------
+// Inflate — RFC 1951
+// ---------------------------------------------------------------------------
+/** The length-code table: base lengths and extra bits for codes 257–285. */
+const LENGTH_BASE = [3, 4, 5, 6, 7, 8, 9, 10, 11, 13, 15, 17, 19, 23, 27, 31, 35, 43, 51, 59, 67, 83, 99, 115, 131, 163, 195, 227, 258];
+const LENGTH_EXTRA = [0, 0, 0, 0, 0, 0, 0, 0, 1, 1, 1, 1, 2, 2, 2, 2, 3, 3, 3, 3, 4, 4, 4, 4, 5, 5, 5, 5, 0];
+/** The distance-code table: base distances and extra bits for codes 0–29. */
+const DIST_BASE = [1, 2, 3, 4, 5, 7, 9, 13, 17, 25, 33, 49, 65, 97, 129, 193, 257, 385, 513, 769, 1025, 1537, 2049, 3073, 4097, 6145, 8193, 12289, 16385, 24577];
+const DIST_EXTRA = [0, 0, 0, 0, 1, 1, 2, 2, 3, 3, 4, 4, 5, 5, 6, 6, 7, 7, 8, 8, 9, 9, 10, 10, 11, 11, 12, 12, 13, 13];
+/** The order in which the code-length-code lengths are stored in a dynamic block. */
+const CLC_ORDER = [16, 17, 18, 0, 8, 7, 9, 6, 10, 5, 11, 4, 12, 3, 13, 2, 14, 1, 15];
+function buildHuffman(lengths) {
+    const counts = new Int32Array(16);
+    for (let i = 0; i < lengths.length; i++)
+        counts[lengths[i]]++;
+    counts[0] = 0;
+    // Sanity: an over-subscribed code set can never have been written by a real deflater.
+    let left = 1;
+    for (let len = 1; len <= 15; len++) {
+        left = (left << 1) - counts[len];
+        if (left < 0)
+            throw new Error('invalid deflate data: over-subscribed Huffman code');
+    }
+    const offsets = new Int32Array(16);
+    for (let len = 1; len < 15; len++)
+        offsets[len + 1] = offsets[len] + counts[len];
+    const symbols = new Int32Array(lengths.length);
+    for (let symbol = 0; symbol < lengths.length; symbol++) {
+        if (lengths[symbol] !== 0)
+            symbols[offsets[lengths[symbol]]++] = symbol;
+    }
+    return { counts, symbols };
+}
+/** The fixed literal/length and distance tables (RFC 1951 §3.2.6), built once. */
+let FIXED_LIT = null;
+let FIXED_DIST = null;
+function fixedTables() {
+    if (!FIXED_LIT) {
+        const litLengths = new Uint8Array(288);
+        for (let i = 0; i < 144; i++)
+            litLengths[i] = 8;
+        for (let i = 144; i < 256; i++)
+            litLengths[i] = 9;
+        for (let i = 256; i < 280; i++)
+            litLengths[i] = 7;
+        for (let i = 280; i < 288; i++)
+            litLengths[i] = 8;
+        FIXED_LIT = buildHuffman(litLengths);
+        FIXED_DIST = buildHuffman(new Uint8Array(30).fill(5));
+    }
+    return { lit: FIXED_LIT, dist: FIXED_DIST };
+}
+class BitReader {
+    constructor(data) {
+        this.data = data;
+        this.pos = 0;
+        this.bitBuf = 0;
+        this.bitCount = 0;
+    }
+    bits(count) {
+        while (this.bitCount < count) {
+            if (this.pos >= this.data.length)
+                throw new Error('invalid deflate data: unexpected end of stream');
+            this.bitBuf |= this.data[this.pos++] << this.bitCount;
+            this.bitCount += 8;
+        }
+        const value = this.bitBuf & ((1 << count) - 1);
+        this.bitBuf >>>= count;
+        this.bitCount -= count;
+        return value;
+    }
+    /** Decode one symbol: walk the canonical code a bit at a time (RFC 1951 §3.2.2). */
+    symbol(huffman) {
+        let code = 0;
+        let first = 0;
+        let index = 0;
+        for (let len = 1; len <= 15; len++) {
+            code |= this.bits(1);
+            const count = huffman.counts[len];
+            if (code - first < count)
+                return huffman.symbols[index + (code - first)];
+            index += count;
+            first = (first + count) << 1;
+            code <<= 1;
+        }
+        throw new Error('invalid deflate data: bad Huffman code');
+    }
+    /** Skip to the next byte boundary and read raw bytes (stored blocks). */
+    stored(length, out) {
+        this.bitBuf = 0;
+        this.bitCount = 0;
+        if (this.pos + length > this.data.length)
+            throw new Error('invalid deflate data: stored block overruns stream');
+        for (let i = 0; i < length; i++)
+            out.push(this.data[this.pos++]);
+    }
+    u16le() {
+        this.bitBuf = 0;
+        this.bitCount = 0;
+        if (this.pos + 2 > this.data.length)
+            throw new Error('invalid deflate data: unexpected end of stream');
+        return this.data[this.pos++] | (this.data[this.pos++] << 8);
+    }
+}
+/** Inflate a raw RFC 1951 stream. Throws on malformed data — wrong pixels are worse than no pixels. */
+function inflateRaw(data) {
+    const reader = new BitReader(data);
+    const out = [];
+    let final = 0;
+    do {
+        final = reader.bits(1);
+        const type = reader.bits(2);
+        if (type === 0) {
+            // Stored: LEN, NLEN (one's complement), then raw bytes.
+            const len = reader.u16le();
+            const nlen = reader.u16le();
+            if ((len ^ 0xffff) !== nlen)
+                throw new Error('invalid deflate data: stored block LEN/NLEN mismatch');
+            reader.stored(len, out);
+            continue;
+        }
+        let lit;
+        let dist;
+        if (type === 1) {
+            ({ lit, dist } = fixedTables());
+        }
+        else if (type === 2) {
+            // Dynamic: the two code tables arrive themselves Huffman-coded (RFC 1951 §3.2.7).
+            const hlit = reader.bits(5) + 257;
+            const hdist = reader.bits(5) + 1;
+            const hclen = reader.bits(4) + 4;
+            const clcLengths = new Uint8Array(19);
+            for (let i = 0; i < hclen; i++)
+                clcLengths[CLC_ORDER[i]] = reader.bits(3);
+            const clc = buildHuffman(clcLengths);
+            const lengths = new Uint8Array(hlit + hdist);
+            let i = 0;
+            while (i < lengths.length) {
+                const sym = reader.symbol(clc);
+                if (sym < 16) {
+                    lengths[i++] = sym;
+                }
+                else if (sym === 16) {
+                    if (i === 0)
+                        throw new Error('invalid deflate data: repeat with no previous length');
+                    const prev = lengths[i - 1];
+                    let repeat = 3 + reader.bits(2);
+                    while (repeat-- > 0)
+                        lengths[i++] = prev;
+                }
+                else if (sym === 17) {
+                    let repeat = 3 + reader.bits(3);
+                    while (repeat-- > 0)
+                        lengths[i++] = 0;
+                }
+                else {
+                    let repeat = 11 + reader.bits(7);
+                    while (repeat-- > 0)
+                        lengths[i++] = 0;
+                }
+                if (i > lengths.length)
+                    throw new Error('invalid deflate data: code lengths overflow');
+            }
+            lit = buildHuffman(lengths.subarray(0, hlit));
+            dist = buildHuffman(lengths.subarray(hlit));
+        }
+        else {
+            throw new Error('invalid deflate data: reserved block type');
+        }
+        // The compressed data proper: literals, end-of-block, and <length, distance> copies.
+        for (;;) {
+            const sym = reader.symbol(lit);
+            if (sym < 256) {
+                out.push(sym);
+            }
+            else if (sym === 256) {
+                break;
+            }
+            else {
+                const li = sym - 257;
+                if (li >= LENGTH_BASE.length)
+                    throw new Error('invalid deflate data: bad length code');
+                const length = LENGTH_BASE[li] + reader.bits(LENGTH_EXTRA[li]);
+                const di = reader.symbol(dist);
+                if (di >= DIST_BASE.length)
+                    throw new Error('invalid deflate data: bad distance code');
+                const distance = DIST_BASE[di] + reader.bits(DIST_EXTRA[di]);
+                if (distance > out.length)
+                    throw new Error('invalid deflate data: distance beyond output');
+                // Byte-at-a-time ON PURPOSE: distance < length is legal (run replication).
+                for (let k = 0, from = out.length - distance; k < length; k++)
+                    out.push(out[from + k]);
+            }
+        }
+    } while (!final);
+    return Uint8Array.from(out);
+}
+/** Inflate an RFC 1950 (zlib) stream — the wrapper a PNG IDAT uses. */
+function zlibInflate(data) {
+    if (data.length < 6)
+        throw new Error('invalid zlib data: too short');
+    const cmf = data[0];
+    const flg = data[1];
+    // CM must be 8 (deflate) and the header checksum must divide by 31 — RFC 1950.
+    if ((cmf & 0x0f) !== 8 || ((cmf << 8) | flg) % 31 !== 0)
+        throw new Error('invalid zlib data: bad header');
+    if (flg & 0x20)
+        throw new Error('invalid zlib data: preset dictionaries are not supported');
+    // The trailing 4 bytes are the adler32; inflateRaw stops at the final block, so simply
+    // passing the remainder (checksum included) is safe.
+    return inflateRaw(data.subarray(2));
+}
+// ---------------------------------------------------------------------------
+// Deflate (stored blocks only) — RFC 1950/1951
+// ---------------------------------------------------------------------------
+/**
+ * Wrap raw bytes as a valid zlib stream using STORED (uncompressed) deflate blocks.
+ *
+ * Every PDF reader's /FlateDecode accepts this — stored blocks are ordinary deflate.
+ * See the header for why we do not compress.
+ */
+function zlibDeflateStored(data) {
+    const blockCount = Math.max(1, Math.ceil(data.length / 65535));
+    const out = new Uint8Array(2 + blockCount * 5 + data.length + 4);
+    let pos = 0;
+    // CMF/FLG: deflate, 32K window; FCHECK makes the 16-bit header divisible by 31.
+    out[pos++] = 0x78;
+    out[pos++] = 0x01;
+    for (let i = 0; i < blockCount; i++) {
+        const start = i * 65535;
+        const chunk = data.subarray(start, Math.min(start + 65535, data.length));
+        out[pos++] = i === blockCount - 1 ? 1 : 0; // BFINAL, BTYPE=00
+        out[pos++] = chunk.length & 0xff;
+        out[pos++] = chunk.length >> 8;
+        out[pos++] = ~chunk.length & 0xff;
+        out[pos++] = (~chunk.length >> 8) & 0xff;
+        out.set(chunk, pos);
+        pos += chunk.length;
+    }
+    const checksum = adler32(data);
+    out[pos++] = (checksum >>> 24) & 0xff;
+    out[pos++] = (checksum >>> 16) & 0xff;
+    out[pos++] = (checksum >>> 8) & 0xff;
+    out[pos++] = checksum & 0xff;
+    return out;
+}
+//# sourceMappingURL=flate.js.map

package/src/libs/renderer/src/export/pdf/index.d.ts

@@ -0,0 +1,4 @@
+export { exportPdf } from './pdf-export';
+export type { PdfExportOptions, PdfExportResult, PdfMetadata } from './pdf-export';
+export { PAGE_SIZES, pageDimensions } from './pdf-primitives';
+export type { PageSize, Orientation, BaseFont, PdfRgb } from './pdf-primitives';