@grafloria/element 0.3.18 → 0.3.20

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

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

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

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

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

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