@grafloria/element 0.3.20 → 0.3.22

package/src/libs/renderer/src/export/pdf/pdf-path.d.ts

@@ -1,17 +0,0 @@
-import { type PathCmd } from '../../canvas/path-geometry';
-/** Emitted PDF path ops, ready to join into a content stream. */
-export type PathOps = string[];
-/**
- * PathCmd[] → PDF operators.
- *
- * Tracks the current point only for the quadratic promotion, which needs the segment's
- * start (a `Q` gives its control point and endpoint, not where it began).
- */
-export declare function cmdsToPdf(cmds: PathCmd[]): PathOps;
-/** An SVG `d` → PDF operators. */
-export declare function svgPathToPdf(d: string): PathOps;
-export declare const pdfRect: (x: number, y: number, w: number, h: number, rx?: number, ry?: number) => PathOps;
-export declare const pdfEllipse: (cx: number, cy: number, rx: number, ry: number) => PathOps;
-export declare const pdfCircle: (cx: number, cy: number, r: number) => PathOps;
-export declare const pdfLine: (x1: number, y1: number, x2: number, y2: number) => PathOps;
-export declare const pdfPoly: (points: string | undefined, close: boolean) => PathOps;

package/src/libs/renderer/src/export/pdf/pdf-path.js

@@ -1,85 +0,0 @@
-"use strict";
-// PathCmd[] → PDF path operators.
-//
-// THE GEOMETRY IS NOT REDECLARED HERE. `canvas/path-geometry.ts` already owns the SVG
-// geometry model for this codebase — `parsePath` (every command, relative forms, the S/T
-// smooth-shorthand reflection, and A → cubics via the W3C F.6 algorithm), the primitive
-// builders, the matrix math. The canvas renderer draws through it and it has its own suite.
-//
-// A second copy of arc→bezier would be a maintenance landmine: two implementations of the
-// same fiddly maths, drifting, with only one of them tested. So this file is a THIN
-// EMITTER — it maps the shared `PathCmd` model onto PDF's operators and does nothing else.
-//
-// PDF's path model is a strict subset of the PathCmd model:
-//   M → `m`,  L → `l`,  C → `c`,  Z → `h`
-//   Q → PDF HAS NO QUADRATIC, so it is promoted to the exactly-equivalent cubic (the two
-//       cubic controls sit 2/3 of the way from each endpoint toward the quadratic's single
-//       control point — this is an identity, not an approximation).
-// Arcs never reach here: `parsePath` has already turned them into cubics.
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.pdfPoly = exports.pdfLine = exports.pdfCircle = exports.pdfEllipse = exports.pdfRect = void 0;
-exports.cmdsToPdf = cmdsToPdf;
-exports.svgPathToPdf = svgPathToPdf;
-const path_geometry_1 = require("../../canvas/path-geometry");
-const pdf_primitives_1 = require("./pdf-primitives");
-/**
- * PathCmd[] → PDF operators.
- *
- * Tracks the current point only for the quadratic promotion, which needs the segment's
- * start (a `Q` gives its control point and endpoint, not where it began).
- */
-function cmdsToPdf(cmds) {
-    const ops = [];
-    let cx = 0;
-    let cy = 0;
-    for (const cmd of cmds) {
-        switch (cmd.op) {
-            case 'M':
-                ops.push(`${(0, pdf_primitives_1.num)(cmd.x)} ${(0, pdf_primitives_1.num)(cmd.y)} m`);
-                cx = cmd.x;
-                cy = cmd.y;
-                break;
-            case 'L':
-                ops.push(`${(0, pdf_primitives_1.num)(cmd.x)} ${(0, pdf_primitives_1.num)(cmd.y)} l`);
-                cx = cmd.x;
-                cy = cmd.y;
-                break;
-            case 'C':
-                ops.push(`${(0, pdf_primitives_1.num)(cmd.x1)} ${(0, pdf_primitives_1.num)(cmd.y1)} ${(0, pdf_primitives_1.num)(cmd.x2)} ${(0, pdf_primitives_1.num)(cmd.y2)} ${(0, pdf_primitives_1.num)(cmd.x)} ${(0, pdf_primitives_1.num)(cmd.y)} c`);
-                cx = cmd.x;
-                cy = cmd.y;
-                break;
-            case 'Q': {
-                // A quadratic IS a cubic: controls at 2/3 from each end toward the single control.
-                const c1x = cx + (2 / 3) * (cmd.x1 - cx);
-                const c1y = cy + (2 / 3) * (cmd.y1 - cy);
-                const c2x = cmd.x + (2 / 3) * (cmd.x1 - cmd.x);
-                const c2y = cmd.y + (2 / 3) * (cmd.y1 - cmd.y);
-                ops.push(`${(0, pdf_primitives_1.num)(c1x)} ${(0, pdf_primitives_1.num)(c1y)} ${(0, pdf_primitives_1.num)(c2x)} ${(0, pdf_primitives_1.num)(c2y)} ${(0, pdf_primitives_1.num)(cmd.x)} ${(0, pdf_primitives_1.num)(cmd.y)} c`);
-                cx = cmd.x;
-                cy = cmd.y;
-                break;
-            }
-            case 'Z':
-                ops.push('h');
-                break;
-        }
-    }
-    return ops;
-}
-/** An SVG `d` → PDF operators. */
-function svgPathToPdf(d) {
-    return cmdsToPdf((0, path_geometry_1.parsePath)(d));
-}
-// The primitives, in PDF form. Each one defers to the shared builder and then emits.
-const pdfRect = (x, y, w, h, rx = 0, ry = rx) => cmdsToPdf((0, path_geometry_1.rectPath)(x, y, w, h, rx, ry));
-exports.pdfRect = pdfRect;
-const pdfEllipse = (cx, cy, rx, ry) => cmdsToPdf((0, path_geometry_1.ellipsePath)(cx, cy, rx, ry));
-exports.pdfEllipse = pdfEllipse;
-const pdfCircle = (cx, cy, r) => cmdsToPdf((0, path_geometry_1.circlePath)(cx, cy, r));
-exports.pdfCircle = pdfCircle;
-const pdfLine = (x1, y1, x2, y2) => cmdsToPdf((0, path_geometry_1.linePath)(x1, y1, x2, y2));
-exports.pdfLine = pdfLine;
-const pdfPoly = (points, close) => cmdsToPdf((0, path_geometry_1.polyPath)(points, close));
-exports.pdfPoly = pdfPoly;
-//# sourceMappingURL=pdf-path.js.map

package/src/libs/renderer/src/export/pdf/pdf-primitives.d.ts

@@ -1,115 +0,0 @@
-/**
- * PDF reals, written short and DETERMINISTIC.
- *
- * `toFixed` then strip trailing zeros: 3 decimals is well below a printer's resolution
- * (a point is 1/72"), and it keeps `0.1+0.2` from writing `0.30000000000000004` into the
- * file — which would make two exports of the same diagram differ in their bytes.
- * `-0` is normalised to `0`, for the same reason.
- */
-export declare function num(value: number): string;
-/** PDF paints in 0–1 channels, not 0–255. Named `PdfRgb` so it cannot be confused with the theme's `Rgb` (which is 0–255). */
-export interface PdfRgb {
-    r: number;
-    g: number;
-    b: number;
-}
-/**
- * Parse a CSS colour to PDF's 0–1 RGB.
- *
- * The hex / rgb() parsing is NOT re-implemented: `themes/contrast.ts` already owns the
- * "parse the colour forms a theme can actually hold" job (#rgb, #rgba, #rrggbb, #rrggbbaa,
- * rgb(), rgba()) and has its own tests. This adds only what is PDF-specific — the 0–255 →
- * 0–1 rescale, the `none`/`transparent`/`url(#…)` cases, and a few CSS keywords.
- *
- * `null` means DO NOT PAINT. Not black: guessing black for a value we could not read would
- * turn one unrecognised colour into a solid black node, which is far worse than a missing
- * fill.
- */
-export declare function parsePdfColor(value: unknown): PdfRgb | null;
-/** The alpha of an `rgba()` / `#rrggbbaa`, or 1. Multiplied into the element's opacity. */
-export declare function parseColorAlpha(value: unknown): number;
-export interface EncodedText {
-    /** WinAnsi bytes, ready for a PDF literal string. */
-    bytes: number[];
-    /** Characters that WinAnsi cannot represent at all (CJK, Arabic, emoji…). */
-    unsupported: string[];
-}
-/**
- * Encode a string to WinAnsiEncoding — what the PDF base-14 fonts speak.
- *
- * Anything outside it (Arabic, CJK, emoji) CANNOT be written with a standard font: it
- * needs an embedded font program with a matching CMap, which means a font parser and a
- * subsetter. We do not have one, so those characters are replaced and REPORTED, and the
- * caller turns that into a loud warning. A silently-mangled label is worse than a
- * missing one, and a silently-empty one is worse than both.
- */
-export declare function encodeWinAnsi(text: string): EncodedText;
-/** Wrap WinAnsi bytes as a PDF literal string, escaping the three characters that bite. */
-export declare function pdfString(bytes: number[]): string;
-export type BaseFont = 'Helvetica' | 'Helvetica-Bold' | 'Helvetica-Oblique' | 'Helvetica-BoldOblique' | 'Times-Roman' | 'Times-Bold' | 'Times-Italic' | 'Times-BoldItalic' | 'Courier' | 'Courier-Bold';
-/**
- * Pick a base-14 font for a CSS font stack.
- *
- * These 14 fonts are built into every PDF reader, so using them means REAL selectable,
- * searchable text with no embedded font program. The diagram's actual face (Inter,
- * system-ui) is not one of them, so the PDF renders in the nearest standard family —
- * that is the documented trade for not shipping a font subsetter.
- */
-export declare function pickBaseFont(fontFamily: unknown, fontWeight: unknown, fontStyle: unknown): BaseFont;
-/** Text width in px, for a base-14 font at a given size. */
-export declare function measureBaseFont(font: BaseFont, text: string, fontSize: number): number;
-/**
- * Assemble a PDF file from its indirect objects.
- *
- * A PDF is: a header, a run of numbered objects, a cross-reference table giving each
- * object's BYTE OFFSET, and a trailer pointing at the catalog. The xref offsets are why
- * this cannot be done with string concatenation alone — they must be measured in BYTES,
- * not characters, so everything is built as bytes from the start.
- */
-export declare class PdfWriter {
-    private readonly objects;
-    /** Reserve an object number (1-based). Lets objects reference each other before both exist. */
-    allocate(): number;
-    /** Fill in an allocated object's body (everything between `N 0 obj` and `endobj`). */
-    set(id: number, body: string | number[]): void;
-    /** A stream object: a dict plus raw data. */
-    setStream(id: number, dict: string, data: number[]): void;
-    build(catalogId: number, infoId?: number | null): Uint8Array;
-}
-/** A PDF's syntax is bytes, not UTF-16 — content streams are Latin-1/WinAnsi. */
-export declare function latin1Bytes(text: string): number[];
-/** UTF-8 bytes, for the few places a PDF wants them (nothing yet — kept honest). */
-export declare const toUtf8: (text: string) => Uint8Array;
-/** Page sizes in POINTS (1/72"), which is PDF's only unit. */
-export declare const PAGE_SIZES: {
-    readonly a4: {
-        readonly width: 595.28;
-        readonly height: 841.89;
-    };
-    readonly letter: {
-        readonly width: 612;
-        readonly height: 792;
-    };
-    readonly legal: {
-        readonly width: 612;
-        readonly height: 1008;
-    };
-    readonly a3: {
-        readonly width: 841.89;
-        readonly height: 1190.55;
-    };
-    readonly tabloid: {
-        readonly width: 792;
-        readonly height: 1224;
-    };
-};
-export type PageSize = keyof typeof PAGE_SIZES;
-export type Orientation = 'portrait' | 'landscape';
-/** The page's dimensions in points, after orientation. */
-export declare function pageDimensions(size: PageSize | {
-    width: number;
-    height: number;
-}, orientation: Orientation): {
-    width: number;
-    height: number;
-};

package/src/libs/renderer/src/export/pdf/pdf-primitives.js

@@ -1,338 +0,0 @@
-"use strict";
-// The PDF primitives: colour, geometry, text encoding, and the file container.
-//
-// Separated from the VNode→PDF painter (`pdf-painter.ts`) so each is testable on its
-// own: this file knows PDF and nothing about diagrams; the painter knows diagrams and
-// speaks to PDF only through here.
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.PAGE_SIZES = exports.toUtf8 = exports.PdfWriter = void 0;
-exports.num = num;
-exports.parsePdfColor = parsePdfColor;
-exports.parseColorAlpha = parseColorAlpha;
-exports.encodeWinAnsi = encodeWinAnsi;
-exports.pdfString = pdfString;
-exports.pickBaseFont = pickBaseFont;
-exports.measureBaseFont = measureBaseFont;
-exports.latin1Bytes = latin1Bytes;
-exports.pageDimensions = pageDimensions;
-const round_trip_1 = require("../round-trip");
-const contrast_1 = require("../../themes/contrast");
-// ---------------------------------------------------------------------------
-// Numbers
-// ---------------------------------------------------------------------------
-/**
- * PDF reals, written short and DETERMINISTIC.
- *
- * `toFixed` then strip trailing zeros: 3 decimals is well below a printer's resolution
- * (a point is 1/72"), and it keeps `0.1+0.2` from writing `0.30000000000000004` into the
- * file — which would make two exports of the same diagram differ in their bytes.
- * `-0` is normalised to `0`, for the same reason.
- */
-function num(value) {
-    if (!Number.isFinite(value))
-        return '0';
-    const rounded = Number(value.toFixed(3));
-    return Object.is(rounded, -0) ? '0' : String(rounded);
-}
-/** The handful of CSS keywords the renderer's themes and defaults actually use. */
-const NAMED = {
-    black: '#000000',
-    white: '#ffffff',
-    red: '#ff0000',
-    green: '#008000',
-    blue: '#0000ff',
-    gray: '#808080',
-    grey: '#808080',
-};
-/**
- * Parse a CSS colour to PDF's 0–1 RGB.
- *
- * The hex / rgb() parsing is NOT re-implemented: `themes/contrast.ts` already owns the
- * "parse the colour forms a theme can actually hold" job (#rgb, #rgba, #rrggbb, #rrggbbaa,
- * rgb(), rgba()) and has its own tests. This adds only what is PDF-specific — the 0–255 →
- * 0–1 rescale, the `none`/`transparent`/`url(#…)` cases, and a few CSS keywords.
- *
- * `null` means DO NOT PAINT. Not black: guessing black for a value we could not read would
- * turn one unrecognised colour into a solid black node, which is far worse than a missing
- * fill.
- */
-function parsePdfColor(value) {
-    var _a;
-    if (typeof value !== 'string')
-        return null;
-    const text = value.trim().toLowerCase();
-    if (text === '' || text === 'none' || text === 'transparent')
-        return null;
-    // url(#gradient): PDF axial shadings are a different beast. The painter resolves the
-    // gradient's first stop and warns; that is not this function's job.
-    if (text.startsWith('url('))
-        return null;
-    const rgb255 = (0, contrast_1.parseColor)((_a = NAMED[text]) !== null && _a !== void 0 ? _a : text);
-    if (!rgb255)
-        return null;
-    return { r: rgb255.r / 255, g: rgb255.g / 255, b: rgb255.b / 255 };
-}
-/** The alpha of an `rgba()` / `#rrggbbaa`, or 1. Multiplied into the element's opacity. */
-function parseColorAlpha(value) {
-    if (typeof value !== 'string')
-        return 1;
-    const text = value.trim().toLowerCase();
-    if (text.startsWith('#')) {
-        const hex = text.slice(1);
-        if (hex.length === 8)
-            return Number.parseInt(hex.slice(6, 8), 16) / 255;
-        if (hex.length === 4) {
-            const c = hex[3];
-            return Number.parseInt(c + c, 16) / 255;
-        }
-        return 1;
-    }
-    const rgba = /^rgba\(([^)]+)\)$/.exec(text);
-    if (rgba) {
-        const parts = rgba[1].split(/[\s,/]+/).filter(Boolean).map(Number);
-        if (parts.length >= 4 && Number.isFinite(parts[3]))
-            return Math.max(0, Math.min(1, parts[3]));
-    }
-    return 1;
-}
-// ---------------------------------------------------------------------------
-// Text encoding
-// ---------------------------------------------------------------------------
-/**
- * The 0x80–0x9F slots of WinAnsiEncoding, which are NOT Latin-1: this is where cp1252
- * puts the curly quotes, the dashes and the ellipsis — every one of which the renderer
- * can emit (its own truncation ellipsis is '…').
- */
-const WIN_ANSI_HIGH = {
-    0x20ac: 0x80, // €
-    0x201a: 0x82,
-    0x0192: 0x83,
-    0x201e: 0x84,
-    0x2026: 0x85, // … — the renderer's ellipsis
-    0x2020: 0x86,
-    0x2021: 0x87,
-    0x02c6: 0x88,
-    0x2030: 0x89,
-    0x0160: 0x8a,
-    0x2039: 0x8b,
-    0x0152: 0x8c,
-    0x017d: 0x8e,
-    0x2018: 0x91, // ‘
-    0x2019: 0x92, // ’
-    0x201c: 0x93, // “
-    0x201d: 0x94, // ”
-    0x2022: 0x95, // •
-    0x2013: 0x96, // –
-    0x2014: 0x97, // —
-    0x02dc: 0x98,
-    0x2122: 0x99, // ™
-    0x0161: 0x9a,
-    0x203a: 0x9b,
-    0x0153: 0x9c,
-    0x017e: 0x9e,
-    0x0178: 0x9f,
-};
-/**
- * Encode a string to WinAnsiEncoding — what the PDF base-14 fonts speak.
- *
- * Anything outside it (Arabic, CJK, emoji) CANNOT be written with a standard font: it
- * needs an embedded font program with a matching CMap, which means a font parser and a
- * subsetter. We do not have one, so those characters are replaced and REPORTED, and the
- * caller turns that into a loud warning. A silently-mangled label is worse than a
- * missing one, and a silently-empty one is worse than both.
- */
-function encodeWinAnsi(text) {
-    const bytes = [];
-    const unsupported = [];
-    for (const char of text) {
-        const code = char.codePointAt(0);
-        if (code >= 0x20 && code <= 0x7e) {
-            bytes.push(code);
-        }
-        else if (WIN_ANSI_HIGH[code] !== undefined) {
-            bytes.push(WIN_ANSI_HIGH[code]);
-        }
-        else if (code >= 0xa0 && code <= 0xff) {
-            bytes.push(code); // Latin-1 supplement lines up with WinAnsi here
-        }
-        else if (code === 0x09) {
-            bytes.push(0x20); // tab → space
-        }
-        else {
-            bytes.push(0x3f); // '?'
-            unsupported.push(char);
-        }
-    }
-    return { bytes, unsupported };
-}
-/** Wrap WinAnsi bytes as a PDF literal string, escaping the three characters that bite. */
-function pdfString(bytes) {
-    let out = '(';
-    for (const byte of bytes) {
-        if (byte === 0x28 || byte === 0x29 || byte === 0x5c)
-            out += '\\'; // ( ) \
-        out += String.fromCharCode(byte);
-    }
-    return out + ')';
-}
-/**
- * Pick a base-14 font for a CSS font stack.
- *
- * These 14 fonts are built into every PDF reader, so using them means REAL selectable,
- * searchable text with no embedded font program. The diagram's actual face (Inter,
- * system-ui) is not one of them, so the PDF renders in the nearest standard family —
- * that is the documented trade for not shipping a font subsetter.
- */
-function pickBaseFont(fontFamily, fontWeight, fontStyle) {
-    const family = String(fontFamily !== null && fontFamily !== void 0 ? fontFamily : '').toLowerCase();
-    const weight = String(fontWeight !== null && fontWeight !== void 0 ? fontWeight : '');
-    const bold = weight === 'bold' || Number(weight) >= 600;
-    const italic = String(fontStyle !== null && fontStyle !== void 0 ? fontStyle : '') === 'italic';
-    if (family.includes('mono') || family.includes('courier') || family.includes('consolas')) {
-        return bold ? 'Courier-Bold' : 'Courier';
-    }
-    if (family.includes('serif') && !family.includes('sans-serif')) {
-        if (bold && italic)
-            return 'Times-BoldItalic';
-        if (bold)
-            return 'Times-Bold';
-        if (italic)
-            return 'Times-Italic';
-        return 'Times-Roman';
-    }
-    if (bold && italic)
-        return 'Helvetica-BoldOblique';
-    if (bold)
-        return 'Helvetica-Bold';
-    if (italic)
-        return 'Helvetica-Oblique';
-    return 'Helvetica';
-}
-/**
- * Helvetica's real glyph advances (AFM units, /1000), for ASCII.
- *
- * Worth the table: every node label is CENTRED, and centring needs a width. With a flat
- * 0.6em guess a centred label sits visibly off-centre in the PDF. With the true advances
- * it lands where the SVG puts it.
- */
-const HELVETICA_WIDTHS = {
-    32: 278, 33: 278, 34: 355, 35: 556, 36: 556, 37: 889, 38: 667, 39: 191,
-    40: 333, 41: 333, 42: 389, 43: 584, 44: 278, 45: 333, 46: 278, 47: 278,
-    48: 556, 49: 556, 50: 556, 51: 556, 52: 556, 53: 556, 54: 556, 55: 556,
-    56: 556, 57: 556, 58: 278, 59: 278, 60: 584, 61: 584, 62: 584, 63: 556,
-    64: 1015, 65: 667, 66: 667, 67: 722, 68: 722, 69: 667, 70: 611, 71: 778,
-    72: 722, 73: 278, 74: 500, 75: 667, 76: 556, 77: 833, 78: 722, 79: 778,
-    80: 667, 81: 778, 82: 722, 83: 667, 84: 611, 85: 722, 86: 667, 87: 944,
-    88: 667, 89: 667, 90: 611, 91: 278, 92: 278, 93: 278, 94: 469, 95: 556,
-    96: 333, 97: 556, 98: 556, 99: 500, 100: 556, 101: 556, 102: 278, 103: 556,
-    104: 556, 105: 222, 106: 222, 107: 500, 108: 222, 109: 833, 110: 556, 111: 556,
-    112: 556, 113: 556, 114: 333, 115: 500, 116: 278, 117: 556, 118: 500, 119: 722,
-    120: 500, 121: 500, 122: 500, 123: 334, 124: 260, 125: 334, 126: 584,
-};
-const BOLD_SCALE = 1.06; // Helvetica-Bold is a touch wider; close enough for centring.
-/** Text width in px, for a base-14 font at a given size. */
-function measureBaseFont(font, text, fontSize) {
-    var _a;
-    if (font.startsWith('Courier')) {
-        return text.length * 0.6 * fontSize; // Courier is monospaced at 600/1000
-    }
-    const bold = font.includes('Bold');
-    let units = 0;
-    for (const char of text) {
-        const code = char.codePointAt(0);
-        units += (_a = HELVETICA_WIDTHS[code]) !== null && _a !== void 0 ? _a : 556; // an unknown glyph gets the mean advance
-    }
-    const width = (units / 1000) * fontSize;
-    return bold ? width * BOLD_SCALE : width;
-}
-// ---------------------------------------------------------------------------
-// The file container
-// ---------------------------------------------------------------------------
-/**
- * Assemble a PDF file from its indirect objects.
- *
- * A PDF is: a header, a run of numbered objects, a cross-reference table giving each
- * object's BYTE OFFSET, and a trailer pointing at the catalog. The xref offsets are why
- * this cannot be done with string concatenation alone — they must be measured in BYTES,
- * not characters, so everything is built as bytes from the start.
- */
-class PdfWriter {
-    constructor() {
-        this.objects = [];
-    }
-    /** Reserve an object number (1-based). Lets objects reference each other before both exist. */
-    allocate() {
-        this.objects.push([]);
-        return this.objects.length;
-    }
-    /** Fill in an allocated object's body (everything between `N 0 obj` and `endobj`). */
-    set(id, body) {
-        this.objects[id - 1] = typeof body === 'string' ? latin1Bytes(body) : body;
-    }
-    /** A stream object: a dict plus raw data. */
-    setStream(id, dict, data) {
-        const head = latin1Bytes(`<< ${dict} /Length ${data.length} >>\nstream\n`);
-        const tail = latin1Bytes('\nendstream');
-        this.objects[id - 1] = [...head, ...data, ...tail];
-    }
-    build(catalogId, infoId) {
-        const out = [];
-        // %PDF-1.4, then a comment line of high bytes marking the file as binary — without
-        // it some tools transfer a PDF in text mode and mangle the stream data.
-        push(out, '%PDF-1.4\n');
-        out.push(0x25, 0xe2, 0xe3, 0xcf, 0xd3, 0x0a);
-        const offsets = [];
-        for (let i = 0; i < this.objects.length; i++) {
-            offsets.push(out.length);
-            push(out, `${i + 1} 0 obj\n`);
-            out.push(...this.objects[i]);
-            push(out, '\nendobj\n');
-        }
-        const xref = out.length;
-        push(out, `xref\n0 ${this.objects.length + 1}\n`);
-        push(out, '0000000000 65535 f \n');
-        for (const offset of offsets) {
-            push(out, `${String(offset).padStart(10, '0')} 00000 n \n`);
-        }
-        // /Info is what a reader shows as Title/Author in its document-properties panel. It
-        // is referenced from the TRAILER, not the catalog — an Info object that exists but is
-        // not named here is invisible, which is a silent way to ship "metadata support" that
-        // sets no metadata.
-        const infoRef = infoId ? ` /Info ${infoId} 0 R` : '';
-        push(out, `trailer\n<< /Size ${this.objects.length + 1} /Root ${catalogId} 0 R${infoRef} >>\n`);
-        push(out, `startxref\n${xref}\n%%EOF\n`);
-        return new Uint8Array(out);
-    }
-}
-exports.PdfWriter = PdfWriter;
-function push(out, text) {
-    for (let i = 0; i < text.length; i++)
-        out.push(text.charCodeAt(i) & 0xff);
-}
-/** A PDF's syntax is bytes, not UTF-16 — content streams are Latin-1/WinAnsi. */
-function latin1Bytes(text) {
-    const out = [];
-    for (let i = 0; i < text.length; i++)
-        out.push(text.charCodeAt(i) & 0xff);
-    return out;
-}
-/** UTF-8 bytes, for the few places a PDF wants them (nothing yet — kept honest). */
-exports.toUtf8 = round_trip_1.utf8.encode;
-// ---------------------------------------------------------------------------
-// Page geometry
-// ---------------------------------------------------------------------------
-/** Page sizes in POINTS (1/72"), which is PDF's only unit. */
-exports.PAGE_SIZES = {
-    a4: { width: 595.28, height: 841.89 },
-    letter: { width: 612, height: 792 },
-    legal: { width: 612, height: 1008 },
-    a3: { width: 841.89, height: 1190.55 },
-    tabloid: { width: 792, height: 1224 },
-};
-/** The page's dimensions in points, after orientation. */
-function pageDimensions(size, orientation) {
-    const base = typeof size === 'string' ? exports.PAGE_SIZES[size] : size;
-    const portrait = { width: base.width, height: base.height };
-    return orientation === 'landscape' ? { width: portrait.height, height: portrait.width } : portrait;
-}
-//# sourceMappingURL=pdf-primitives.js.map

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

@@ -1,25 +0,0 @@
-/** Everything the PDF writer needs to embed one image XObject. */
-export interface PdfImage {
-    width: number;
-    height: number;
-    /** A PDF colourspace expression: `/DeviceRGB`, `/DeviceGray`, or `[/Indexed …]`. */
-    colorSpace: string;
-    bitsPerComponent: number;
-    /** The image stream, already encoded for `filter`. */
-    data: Uint8Array;
-    filter: '/FlateDecode' | '/DCTDecode';
-    /** The `/DecodeParms` dict (PNG-predictor passthrough), or null. */
-    decodeParms: string | null;
-    /** The `/Decode` array (Adobe-inverted CMYK JPEGs), or null for the default mapping. */
-    decode: string | null;
-    /** The alpha plane as a /DeviceGray zlib stream, or null for opaque images. */
-    smask: {
-        data: Uint8Array;
-        bitsPerComponent: number;
-    } | null;
-}
-/**
- * Decode a `data:image/png` / `data:image/jpeg` URL into a PDF-embeddable image.
- * Returns null (after calling `warn`) for anything it cannot embed FAITHFULLY.
- */
-export declare function decodeDataUrlImage(href: string, warn: (message: string) => void): PdfImage | null;