@grafloria/element 0.3.20 → 0.3.21

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

@@ -1,116 +0,0 @@
-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

@@ -1,245 +0,0 @@
-"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

@@ -1,13 +0,0 @@
-/** 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

@@ -1,287 +0,0 @@
-"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

@@ -1,4 +0,0 @@
-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';