@grafloria/element 0.3.18 → 0.3.20

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

@@ -0,0 +1,1076 @@
+"use strict";
+// Vector PDF (Card 4) — a TRUE vector PDF with selectable, searchable text.
+//
+// THE DEPENDENCY DECISION (the card asks for it explicitly)
+// ---------------------------------------------------------
+// The named pipeline is svg2pdf.js + jsPDF. We do NOT use it, for three reasons that all
+// point the same way:
+//
+//  1. svg2pdf.js NEEDS A DOM. It walks a live `SVGElement`, and leans on `getBBox()` and
+//     `getComputedStyle()` — browser layout APIs. jsdom does not implement `getBBox` (it
+//     returns zeros), so in Node it does not merely need a shim, it silently produces an
+//     EMPTY PDF. Adopting it would therefore break the two things this module is FOR:
+//     the DOM-free guarantee (a node-environment test pins it) and the headless-server
+//     story that is Card 6's whole differentiator.
+//  2. It is ~450KB (jsPDF ~350 + svg2pdf ~100) shipped to every browser consumer, to
+//     re-derive a picture we already hold in a clean, fully-resolved VNode tree.
+//  3. Its input would be our SVG STRING — so we would serialize a tree to XML, hand it to
+//     a library to re-parse into a DOM, and have it walk that DOM. We already have the
+//     tree, already flattened (every `var(--…)` resolved into a concrete value). Painting
+//     straight from it is both less code and strictly more faithful.
+//
+// So the PDF is written directly. This is not "faking it" — the output is a real vector
+// PDF: paths are paths, and text is text (`BT`/`Tj`), so it is selectable and searchable
+// in any reader, and it scales without pixelation.
+//
+// WHAT IT COSTS — stated plainly, because these are real limits:
+//   • FONTS are the PDF base-14 (Helvetica/Times/Courier). Those are built into every
+//     reader, so text needs no embedded font program — but the diagram's actual face
+//     (Inter, system-ui) is NOT one of them, so a PDF renders in the nearest standard
+//     family. Embedding the real face would need a font parser + subsetter.
+//   • TEXT OUTSIDE WinAnsi (Arabic, CJK, emoji) cannot be written with a standard font.
+//     Those characters are replaced with '?' and reported in `warnings` — loudly, because
+//     a silently-mangled label is worse than a missing one.
+//   • GRADIENT FILLS are REAL: linear → /ShadingType 2, radial → /ShadingType 3, painted
+//     as `sh` clipped to the shape (see the shading section for why not a pattern fill).
+//     Stop OPACITY is real too: a luminosity soft mask (a DeviceGray transparency-group
+//     form painting the alpha ramp, wired through /ExtGState /SMask). Gradient-filled
+//     TEXT is real: text rendering mode 7 turns the glyphs into the clip and the shading
+//     paints through. What still flattens to the first stop, with a warning: gradient
+//     STROKES — a shading through a stroke needs either the stroke outline as a clip
+//     (PDF cannot build one) or a shading pattern whose /Matrix lives in page space,
+//     i.e. exactly the accumulated-CTM bookkeeping the sh approach exists to avoid.
+//   • IMAGES embed as real XObjects for data: PNGs — RGBA's alpha splits into an /SMask,
+//     interlaced (Adam7) PNGs are de-interlaced, 16-bit samples downsample to their high
+//     byte (< 0.4% error) — and JPEGs (DCTDecode passthrough), including CMYK: the Adobe
+//     APP14 convention stores inverted ink values, undone via /Decode. Still refused,
+//     loudly: external URLs (fetching would make the export impure) and sub-8-bit PNGs.
+//     RGBA re-compression is stored-block (see flate.ts): raw-size streams, correct
+//     pixels.
+//   • ELEMENT clip-paths (clip-path="url(#…)" with userSpaceOnUse shapes) clip for real
+//     via W n. clipPathUnits="objectBoundingBox" warns and paints unclipped.
+//   • BLURRED elements (the node drop shadow) are DROPPED. PDF has no gaussian blur, and
+//     drawing the shadow un-blurred would put a hard black slab behind every node — far
+//     worse than no shadow.
+//   • foreignObject cannot be represented at all.
+//
+// Everything here is pure and deterministic: same tree ⇒ same bytes.
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.exportPdf = exportPdf;
+const pdf_primitives_1 = require("./pdf-primitives");
+const pdf_path_1 = require("./pdf-path");
+const png_1 = require("./png");
+const bounds_1 = require("../bounds");
+// The shared geometry module — see pdf-path.ts.
+const path_geometry_1 = require("../../canvas/path-geometry");
+const style_flattener_1 = require("../style-flattener");
+const patch_1 = require("../../vnode/patch");
+const default_light_theme_1 = require("../../themes/default-light-theme");
+function resolveMargins(margin) {
+    if (typeof margin === 'number')
+        return { top: margin, right: margin, bottom: margin, left: margin };
+    if (margin)
+        return margin;
+    return { top: 36, right: 36, bottom: 36, left: 36 };
+}
+class ContentStream {
+    constructor() {
+        this.ops = [];
+        this.state = { fill: null, stroke: null, lineWidth: null, dash: null, alpha: null, font: null };
+        /** ExtGState names for the alphas we used: PDF puts constant alpha in a resource dict. */
+        this.alphas = new Set();
+        this.fonts = new Set();
+    }
+    push(op) {
+        this.ops.push(op);
+    }
+    save() {
+        this.ops.push('q');
+    }
+    restore() {
+        this.ops.push('Q');
+        // A `Q` rolls the graphics state back to whatever it was at the matching `q`, and we
+        // do not track that — so forget our cache rather than skip an op we still need.
+        this.state = { fill: null, stroke: null, lineWidth: null, dash: null, alpha: null, font: null };
+    }
+    setFill(rgb) {
+        const op = `${(0, pdf_primitives_1.num)(rgb.r)} ${(0, pdf_primitives_1.num)(rgb.g)} ${(0, pdf_primitives_1.num)(rgb.b)} rg`;
+        if (this.state.fill === op)
+            return;
+        this.state.fill = op;
+        this.ops.push(op);
+    }
+    setStroke(rgb) {
+        const op = `${(0, pdf_primitives_1.num)(rgb.r)} ${(0, pdf_primitives_1.num)(rgb.g)} ${(0, pdf_primitives_1.num)(rgb.b)} RG`;
+        if (this.state.stroke === op)
+            return;
+        this.state.stroke = op;
+        this.ops.push(op);
+    }
+    setLineWidth(width) {
+        if (this.state.lineWidth === width)
+            return;
+        this.state.lineWidth = width;
+        this.ops.push(`${(0, pdf_primitives_1.num)(width)} w`);
+    }
+    setDash(dash) {
+        const op = dash ? `[${dash}] 0 d` : '[] 0 d';
+        if (this.state.dash === op)
+            return;
+        this.state.dash = op;
+        this.ops.push(op);
+    }
+    setAlpha(alpha) {
+        const rounded = Number(alpha.toFixed(3));
+        if (this.state.alpha === rounded)
+            return;
+        this.state.alpha = rounded;
+        this.alphas.add(rounded);
+        this.ops.push(`/GS${alphaName(rounded)} gs`);
+    }
+    setFont(font, size) {
+        const op = `/F${fontIndex(font)} ${(0, pdf_primitives_1.num)(size)} Tf`;
+        if (this.state.font === op)
+            return;
+        this.state.font = op;
+        this.fonts.add(font);
+        this.ops.push(op);
+    }
+    concat(m) {
+        this.ops.push(`${(0, pdf_primitives_1.num)(m.a)} ${(0, pdf_primitives_1.num)(m.b)} ${(0, pdf_primitives_1.num)(m.c)} ${(0, pdf_primitives_1.num)(m.d)} ${(0, pdf_primitives_1.num)(m.e)} ${(0, pdf_primitives_1.num)(m.f)} cm`);
+    }
+}
+const BASE_FONTS = [
+    'Helvetica',
+    'Helvetica-Bold',
+    'Helvetica-Oblique',
+    'Helvetica-BoldOblique',
+    'Times-Roman',
+    'Times-Bold',
+    'Times-Italic',
+    'Times-BoldItalic',
+    'Courier',
+    'Courier-Bold',
+];
+const fontIndex = (font) => BASE_FONTS.indexOf(font) + 1;
+const alphaName = (alpha) => String(Math.round(alpha * 1000));
+/** Elements that draw nothing and whose children are references. */
+const NON_PAINTING = new Set([
+    'defs', 'title', 'desc', 'metadata', 'linearGradient', 'radialGradient',
+    'stop', 'filter', 'marker', 'clipPath', 'mask', 'pattern', 'style',
+]);
+function nn(value, fallback = 0) {
+    const n = Number(value);
+    return Number.isFinite(n) ? n : fallback;
+}
+/**
+ * Export a rendered VNode tree as a vector PDF.
+ */
+function exportPdf(root, options = {}) {
+    var _a, _b, _c, _d, _e;
+    const warnings = [];
+    const margins = resolveMargins(options.margin);
+    const page = (0, pdf_primitives_1.pageDimensions)((_a = options.pageSize) !== null && _a !== void 0 ? _a : 'a4', (_b = options.orientation) !== null && _b !== void 0 ? _b : 'landscape');
+    // The world rectangle(s) to draw. One page unless the paginator supplied a grid.
+    const content = (_c = options.viewBox) !== null && _c !== void 0 ? _c : (() => {
+        var _a;
+        const bounds = (0, bounds_1.vnodeBounds)(root);
+        const pad = (_a = options.padding) !== null && _a !== void 0 ? _a : 20;
+        if (!bounds)
+            return { x: 0, y: 0, width: 100, height: 100 };
+        return { x: bounds.x - pad, y: bounds.y - pad, width: bounds.width + pad * 2, height: bounds.height + pad * 2 };
+    })();
+    // Normalise: a bare Rectangle means "paint the whole window".
+    const pages = (((_d = options.pages) === null || _d === void 0 ? void 0 : _d.length) ? options.pages : [content]).map(page => {
+        var _a;
+        const rect = 'rect' in page ? page.rect : page;
+        const clip = 'rect' in page ? ((_a = page.clip) !== null && _a !== void 0 ? _a : rect) : page;
+        return { rect, clip };
+    });
+    // Gradients / patterns / clip paths are resolved by id from <defs> — collect first.
+    const defs = collectDefs(root);
+    // The stylesheet, flattened — the same resolver the SVG exporter uses.
+    const classStyles = (0, style_flattener_1.createClassStyleResolver)((_e = options.theme) !== null && _e !== void 0 ? _e : default_light_theme_1.LIGHT_THEME, warnings);
+    const ctx = {
+        defs,
+        shadings: new ShadingRegistry(),
+        softMasks: new SoftMaskRegistry(),
+        images: new ImageRegistry(),
+        warnings,
+        classStyles,
+    };
+    const writer = new pdf_primitives_1.PdfWriter();
+    const catalogId = writer.allocate();
+    const pagesId = writer.allocate();
+    const pageIds = [];
+    const contentIds = [];
+    const streams = [];
+    for (let i = 0; i < pages.length; i++) {
+        pageIds.push(writer.allocate());
+        contentIds.push(writer.allocate());
+    }
+    const boxWidth = page.width - margins.left - margins.right;
+    const boxHeight = page.height - margins.top - margins.bottom;
+    pages.forEach(({ rect, clip }, index) => {
+        const stream = new ContentStream();
+        streams.push(stream);
+        // Fit the world rectangle into the page's content box, preserving aspect, centred.
+        const scale = Math.min(boxWidth / rect.width, boxHeight / rect.height);
+        const drawWidth = rect.width * scale;
+        const drawHeight = rect.height * scale;
+        const offsetX = margins.left + (boxWidth - drawWidth) / 2;
+        const offsetY = margins.bottom + (boxHeight - drawHeight) / 2;
+        if (options.backgroundColor) {
+            const bg = (0, pdf_primitives_1.parsePdfColor)(options.backgroundColor);
+            if (bg) {
+                stream.save();
+                stream.setFill(bg);
+                stream.push(`0 0 ${(0, pdf_primitives_1.num)(page.width)} ${(0, pdf_primitives_1.num)(page.height)} re`);
+                stream.push('f');
+                stream.restore();
+            }
+        }
+        stream.save();
+        // PDF's origin is BOTTOM-left with y up; SVG's is TOP-left with y down. This one
+        // matrix does the flip, the fit, and the world offset in a single CTM — so every
+        // coordinate below is written in the SVG's own space and lands in the right place.
+        //   x_pdf = offsetX + (x_svg - rect.x) * scale
+        //   y_pdf = offsetY + drawHeight - (y_svg - rect.y) * scale
+        const ctm = {
+            a: scale,
+            b: 0,
+            c: 0,
+            d: -scale,
+            e: offsetX - rect.x * scale,
+            f: offsetY + drawHeight + rect.y * scale,
+        };
+        stream.concat(ctm);
+        // Clip to what this page actually PAINTS. That is `clip`, not `rect`: when the
+        // paginator pulled a break back to spare a node, the clip is narrower than the window,
+        // and the page shows white space instead of a sliced-in-half box.
+        stream.push(`${(0, pdf_primitives_1.num)(clip.x)} ${(0, pdf_primitives_1.num)(clip.y)} ${(0, pdf_primitives_1.num)(clip.width)} ${(0, pdf_primitives_1.num)(clip.height)} re`);
+        stream.push('W n');
+        paint(root, stream, ctx);
+        stream.restore();
+        if (options.pageNumbers && pages.length > 0) {
+            paintPageNumber(stream, index + 1, pages.length, page, margins);
+        }
+    });
+    // ---- assemble the document ------------------------------------------------
+    const usedFonts = new Set();
+    const usedAlphas = new Set();
+    for (const stream of streams) {
+        stream.fonts.forEach(f => usedFonts.add(f));
+        stream.alphas.forEach(a => usedAlphas.add(a));
+    }
+    const fontIds = new Map();
+    for (const font of BASE_FONTS) {
+        if (usedFonts.has(font))
+            fontIds.set(font, writer.allocate());
+    }
+    const fontResources = [...fontIds.entries()]
+        .map(([font, id]) => `/F${fontIndex(font)} ${id} 0 R`)
+        .join(' ');
+    // Constant alpha lives in an ExtGState, not in an operator — /ca fill, /CA stroke.
+    const alphaResources = [...usedAlphas]
+        .sort((a, b) => a - b)
+        .map(alpha => `/GS${alphaName(alpha)} << /Type /ExtGState /ca ${(0, pdf_primitives_1.num)(alpha)} /CA ${(0, pdf_primitives_1.num)(alpha)} >>`)
+        .join(' ');
+    // Image XObjects: one stream object per distinct image, plus its /SMask stream when the
+    // source PNG carried alpha. Wiring the SMask by reference is the whole point — an alpha
+    // plane that exists but is not named in the image dict renders opaque, silently.
+    const imageEntries = ctx.images.entries();
+    const imageRefs = [];
+    for (const { name, image } of imageEntries) {
+        let smaskRef = '';
+        if (image.smask) {
+            const smaskId = writer.allocate();
+            writer.setStream(smaskId, `/Type /XObject /Subtype /Image /Width ${image.width} /Height ${image.height} ` +
+                `/ColorSpace /DeviceGray /BitsPerComponent ${image.smask.bitsPerComponent} /Filter /FlateDecode`, Array.from(image.smask.data));
+            smaskRef = ` /SMask ${smaskId} 0 R`;
+        }
+        const imageId = writer.allocate();
+        const decodeParms = image.decodeParms ? ` /DecodeParms ${image.decodeParms}` : '';
+        // /Decode is how an Adobe-inverted CMYK JPEG comes out the right colours — dropping
+        // it here renders every such image inverted (red → cyan) with no other symptom.
+        const decode = image.decode ? ` /Decode ${image.decode}` : '';
+        writer.setStream(imageId, `/Type /XObject /Subtype /Image /Width ${image.width} /Height ${image.height} ` +
+            `/ColorSpace ${image.colorSpace} /BitsPerComponent ${image.bitsPerComponent} ` +
+            `/Filter ${image.filter}${decodeParms}${decode}${smaskRef}`, Array.from(image.data));
+        imageRefs.push(`/${name} ${imageId} 0 R`);
+    }
+    const shadingResources = ctx.shadings
+        .entries()
+        .map(([name, dict]) => `/${name} ${dict}`)
+        .join(' ');
+    // Luminosity soft masks: a Form XObject painting the alpha ramp in DeviceGray, and an
+    // ExtGState pointing at it. The /Transparency group's /CS MUST be DeviceGray — an RGB
+    // group's luminosity is a different function of the ramp, and the mask silently warps.
+    const softMaskResources = ctx.softMasks
+        .entries()
+        .map(mask => {
+        const formId = writer.allocate();
+        writer.setStream(formId, `/Type /XObject /Subtype /Form /BBox [${mask.bbox}] ` +
+            `/Group << /S /Transparency /CS /DeviceGray >> ` +
+            `/Resources << /Shading << /G0 ${mask.shading} >> >>`, (0, pdf_primitives_1.latin1Bytes)('/G0 sh'));
+        return `/${mask.name} << /Type /ExtGState /SMask << /S /Luminosity /G ${formId} 0 R >> >>`;
+    })
+        .join(' ');
+    const resources = `<< /Font << ${fontResources} >> ` +
+        `/ExtGState << ${alphaResources}${softMaskResources ? ` ${softMaskResources}` : ''} >> ` +
+        (shadingResources ? `/Shading << ${shadingResources} >> ` : '') +
+        (imageRefs.length ? `/XObject << ${imageRefs.join(' ')} >> ` : '') +
+        `/ProcSet [/PDF /Text${imageRefs.length ? ' /ImageB /ImageC /ImageI' : ''}] >>`;
+    streams.forEach((stream, index) => {
+        writer.set(pageIds[index], `<< /Type /Page /Parent ${pagesId} 0 R ` +
+            `/MediaBox [0 0 ${(0, pdf_primitives_1.num)(page.width)} ${(0, pdf_primitives_1.num)(page.height)}] ` +
+            `/Resources ${resources} ` +
+            `/Contents ${contentIds[index]} 0 R >>`);
+        writer.setStream(contentIds[index], '', (0, pdf_primitives_1.latin1Bytes)(stream.ops.join('\n')));
+    });
+    for (const [font, id] of fontIds) {
+        writer.set(id, `<< /Type /Font /Subtype /Type1 /BaseFont /${font} /Encoding /WinAnsiEncoding >>`);
+    }
+    writer.set(pagesId, `<< /Type /Pages /Kids [${pageIds.map(id => `${id} 0 R`).join(' ')}] /Count ${pageIds.length} >>`);
+    const infoId = buildInfo(writer, options.metadata);
+    writer.set(catalogId, `<< /Type /Catalog /Pages ${pagesId} 0 R >>`);
+    return { pdf: writer.build(catalogId, infoId), pageCount: pages.length, warnings: dedupe(warnings) };
+}
+function buildInfo(writer, metadata) {
+    if (!metadata)
+        return null;
+    const entries = [];
+    const add = (key, value) => {
+        if (value)
+            entries.push(`/${key} ${(0, pdf_primitives_1.pdfString)((0, pdf_primitives_1.encodeWinAnsi)(value).bytes)}`);
+    };
+    add('Title', metadata.title);
+    add('Author', metadata.author);
+    add('Subject', metadata.subject);
+    add('Keywords', metadata.keywords);
+    entries.push('/Producer (Grafloria)');
+    if (metadata.creationDate)
+        add('CreationDate', toPdfDate(metadata.creationDate));
+    const id = writer.allocate();
+    writer.set(id, `<< ${entries.join(' ')} >>`);
+    return id;
+}
+/** ISO-8601 → PDF's own `D:YYYYMMDDHHmmSS` date literal. */
+function toPdfDate(iso) {
+    const date = new Date(iso);
+    if (Number.isNaN(date.getTime()))
+        return iso;
+    const pad = (n) => String(n).padStart(2, '0');
+    return (`D:${date.getUTCFullYear()}${pad(date.getUTCMonth() + 1)}${pad(date.getUTCDate())}` +
+        `${pad(date.getUTCHours())}${pad(date.getUTCMinutes())}${pad(date.getUTCSeconds())}Z`);
+}
+/**
+ * THE ELEMENT'S REAL PAINT — the CSS cascade, resolved.
+ *
+ * This is not optional decoration. In CSS mode (the live default) a node's fill and a
+ * link's stroke are NOT on the element: they come from the injected stylesheet, and the
+ * VNode carries only `class="diagram-node"`. Painting the raw props would therefore give
+ * every link no stroke and every node no fill — i.e. a nearly BLANK PDF. (It did. That is
+ * how this was found.)
+ *
+ * So the same flattener the SVG exporter uses is applied here, in the same CSS priority
+ * order — presentation attribute < author rule < inline style — and keys are normalised
+ * through `attrNameForProp`, the mapping SHARED with the DOM patcher. Sharing it is what
+ * stops a `strokeWidth` prop and a `stroke-width` rule from both surviving and the wrong
+ * one winning.
+ */
+function resolved(vnode, ctx) {
+    var _a;
+    const props = (_a = vnode.props) !== null && _a !== void 0 ? _a : {};
+    const out = {};
+    // (1) presentation attributes — the lowest layer
+    for (const key of Object.keys(props)) {
+        const value = props[key];
+        if (value === null || value === undefined || typeof value === 'function')
+            continue;
+        if (key === 'style' || key === 'className' || key === 'textContent' || key === 'innerHTML')
+            continue;
+        out[(0, patch_1.attrNameForProp)(key)] = String(value);
+    }
+    // (2) the stylesheet — an author rule BEATS a presentation attribute
+    const className = props['className'];
+    if (typeof className === 'string' && className.trim() !== '') {
+        Object.assign(out, ctx.classStyles(className.trim().split(/\s+/)));
+    }
+    // (3) the element's own inline style — the cascade's winner
+    const style = (0, patch_1.serializeStyle)(props['style']);
+    if (style) {
+        for (const declaration of style.split(';')) {
+            const colon = declaration.indexOf(':');
+            if (colon < 0)
+                continue;
+            const prop = declaration.slice(0, colon).trim();
+            const value = declaration.slice(colon + 1).trim();
+            if (prop && value)
+                out[prop] = value;
+        }
+    }
+    return out;
+}
+/** Both prop spellings occur: the capture emits `stop-color`, hand-built trees `stopColor`. */
+function stopProp(vnode, kebab, camel) {
+    var _a, _b, _c;
+    return (_b = (_a = vnode.props) === null || _a === void 0 ? void 0 : _a[kebab]) !== null && _b !== void 0 ? _b : (_c = vnode.props) === null || _c === void 0 ? void 0 : _c[camel];
+}
+function parseStops(vnode) {
+    var _a, _b;
+    const stops = [];
+    for (const child of (_a = vnode.children) !== null && _a !== void 0 ? _a : []) {
+        if (!child || typeof child !== 'object' || child.type !== 'stop')
+            continue;
+        const colorValue = stopProp(child, 'stop-color', 'stopColor');
+        const color = (0, pdf_primitives_1.parsePdfColor)(colorValue);
+        if (!color)
+            continue;
+        // Offsets arrive as numbers, "0.5" or "50%".
+        const rawOffset = (_b = child.props) === null || _b === void 0 ? void 0 : _b['offset'];
+        let offset = 0;
+        if (typeof rawOffset === 'number')
+            offset = rawOffset;
+        else if (typeof rawOffset === 'string') {
+            const pct = rawOffset.trim().endsWith('%');
+            const parsed = Number.parseFloat(rawOffset);
+            offset = Number.isFinite(parsed) ? (pct ? parsed / 100 : parsed) : 0;
+        }
+        const stopOpacity = nn(stopProp(child, 'stop-opacity', 'stopOpacity'), 1);
+        stops.push({
+            offset: Math.max(0, Math.min(1, offset)),
+            color,
+            alpha: stopOpacity * (0, pdf_primitives_1.parseColorAlpha)(colorValue),
+        });
+    }
+    // PDF stitching wants monotonic domains; SVG clamps out-of-order offsets the same way.
+    for (let i = 1; i < stops.length; i++)
+        stops[i].offset = Math.max(stops[i].offset, stops[i - 1].offset);
+    return stops;
+}
+/** Every def the painter can resolve by id, in one walk. */
+function collectDefs(root) {
+    const defs = { gradients: new Map(), patterns: new Map(), clipPaths: new Map() };
+    const walk = (vnode) => {
+        var _a, _b, _c;
+        if (!vnode || typeof vnode !== 'object')
+            return;
+        const id = (_a = vnode.props) === null || _a === void 0 ? void 0 : _a['id'];
+        if ((vnode.type === 'linearGradient' || vnode.type === 'radialGradient') && typeof id === 'string') {
+            const props = (_b = vnode.props) !== null && _b !== void 0 ? _b : {};
+            const stops = parseStops(vnode);
+            if (stops.length > 0) {
+                defs.gradients.set(id, {
+                    kind: vnode.type === 'linearGradient' ? 'linear' : 'radial',
+                    objectBoundingBox: props['gradientUnits'] !== 'userSpaceOnUse',
+                    coords: vnode.type === 'linearGradient'
+                        ? { x1: nn(props['x1'], 0), y1: nn(props['y1'], 0), x2: nn(props['x2'], 1), y2: nn(props['y2'], 0) }
+                        : { cx: nn(props['cx'], 0.5), cy: nn(props['cy'], 0.5), r: nn(props['r'], 0.5) },
+                    stops,
+                });
+            }
+        }
+        else if (vnode.type === 'pattern' && typeof id === 'string') {
+            defs.patterns.set(id, vnode);
+        }
+        else if (vnode.type === 'clipPath' && typeof id === 'string') {
+            defs.clipPaths.set(id, vnode);
+        }
+        for (const child of (_c = vnode.children) !== null && _c !== void 0 ? _c : [])
+            walk(child);
+    };
+    walk(root);
+    return defs;
+}
+// ---------------------------------------------------------------------------
+// Document-level resources the painter accumulates while painting.
+// ---------------------------------------------------------------------------
+/** Shadings, deduped by their full dict (same gradient + same geometry = one resource). */
+class ShadingRegistry {
+    constructor() {
+        this.byDict = new Map();
+    }
+    nameFor(dict) {
+        const existing = this.byDict.get(dict);
+        if (existing)
+            return existing;
+        const name = `Sh${this.byDict.size + 1}`;
+        this.byDict.set(dict, name);
+        return name;
+    }
+    entries() {
+        return [...this.byDict.entries()].map(([dict, name]) => [name, dict]);
+    }
+    get size() {
+        return this.byDict.size;
+    }
+}
+/**
+ * Luminosity soft masks — one per distinct (gray alpha-ramp shading, bbox) pair.
+ *
+ * Each entry becomes a Form XObject painting the alpha ramp as a DEVICEGRAY shading
+ * (stop alpha 1 → white, 0 → black) inside a /Transparency group, plus an ExtGState
+ * whose /SMask /Luminosity points at it. `gs` that state and every later paint is
+ * multiplied by the mask — which is exactly SVG's per-stop opacity.
+ */
+class SoftMaskRegistry {
+    constructor() {
+        this.byKey = new Map();
+    }
+    nameFor(shading, bbox) {
+        const key = `${bbox}|${shading}`;
+        const existing = this.byKey.get(key);
+        if (existing)
+            return existing.name;
+        const name = `GSM${this.byKey.size + 1}`;
+        this.byKey.set(key, { name, shading, bbox });
+        return name;
+    }
+    entries() {
+        return [...this.byKey.values()];
+    }
+}
+/** Images, deduped by href — one XObject however many times a data URL is drawn. */
+class ImageRegistry {
+    constructor() {
+        /** null = decode failed (already warned) — remembered so one bad image warns once. */
+        this.byHref = new Map();
+        this.count = 0;
+    }
+    resolve(href, warn) {
+        const cached = this.byHref.get(href);
+        if (cached !== undefined)
+            return cached;
+        const image = (0, png_1.decodeDataUrlImage)(href, warn);
+        const entry = image ? { name: `Im${++this.count}`, image } : null;
+        this.byHref.set(href, entry);
+        return entry;
+    }
+    entries() {
+        return [...this.byHref.values()].filter((e) => e !== null);
+    }
+}
+/**
+ * Walk the tree, painting into the content stream.
+ *
+ * There is no parent-matrix parameter here on purpose: PDF's CTM is STATEFUL, and `q`/`Q`
+ * are a real stack. So a group's transform is pushed with `cm` and popped with `Q`, and
+ * the composition happens in the PDF itself — exactly as it does in SVG. Threading an
+ * accumulated matrix through as well would apply every transform twice.
+ */
+function paint(vnode, stream, ctx) {
+    var _a;
+    if (!vnode || typeof vnode !== 'object' || typeof vnode.type !== 'string')
+        return;
+    if (NON_PAINTING.has(vnode.type))
+        return;
+    // The CASCADE, resolved — see `resolved()`. Everything below reads from this map, never
+    // from the raw props, because in CSS mode the raw props carry no paint at all.
+    const style = resolved(vnode, ctx);
+    if (style['display'] === 'none')
+        return;
+    if (vnode.type === 'foreignObject') {
+        ctx.warnings.push('foreignObject cannot be represented in PDF (it is HTML, and PDF has no HTML) — omitted. ' +
+            'Nodes rendered as HTML components will be missing from the PDF.');
+        return;
+    }
+    // A blur is a filter, and PDF has no filters. Dropping the element beats drawing the
+    // node shadow as a hard black slab.
+    const filter = style['filter'];
+    if (typeof filter === 'string' && /blur\(|url\(#grafloria-blur/.test(filter)) {
+        ctx.warnings.push('blurred elements (the node drop shadow) are omitted — PDF has no gaussian blur');
+        return;
+    }
+    const local = (0, path_geometry_1.parseTransform)(style['transform']);
+    const hasTransform = !isIdentity(local);
+    // An element's clip path rides INSIDE its own transform: SVG applies the transform to
+    // element and clip alike (they move together), so the clip ops are emitted after `cm`.
+    const clip = resolveClip(style['clip-path'], ctx);
+    if (clip === 'hide')
+        return; // an EMPTY clipPath clips everything away — SVG semantics
+    const scoped = hasTransform || clip !== null;
+    if (scoped)
+        stream.save();
+    if (hasTransform)
+        stream.concat(local);
+    if (clip) {
+        for (const op of clip)
+            stream.push(op);
+        stream.push('W n');
+    }
+    drawElement(vnode, style, stream, ctx);
+    for (const child of (_a = vnode.children) !== null && _a !== void 0 ? _a : []) {
+        if (child && typeof child === 'object')
+            paint(child, stream, ctx);
+    }
+    if (scoped)
+        stream.restore();
+}
+/**
+ * `clip-path: url(#…)` → the clip's PDF path ops, or null for "paint unclipped", or
+ * 'hide' when the clip resolves to nothing (SVG: an empty clip path renders nothing).
+ *
+ * Multiple clip shapes concatenate into ONE path before a single `W n` — nonzero winding
+ * over same-direction subpaths is their union, which is SVG's multi-child semantics.
+ * Every refusal (missing def, objectBoundingBox units) WARNS and paints unclipped:
+ * bleeding content is a visible flaw, silently vanished content is a lost diagram.
+ */
+function resolveClip(value, ctx) {
+    var _a, _b, _c;
+    if (typeof value !== 'string')
+        return null;
+    const ref = /^url\(#([^)]+)\)$/.exec(value.trim());
+    if (!ref)
+        return value.trim() === 'none' ? null : null;
+    const def = ctx.defs.clipPaths.get(ref[1]);
+    if (!def) {
+        ctx.warnings.push(`a clip-path references "#${ref[1]}", which is not in the tree — the content is painted UNCLIPPED`);
+        return null;
+    }
+    if (((_a = def.props) === null || _a === void 0 ? void 0 : _a['clipPathUnits']) === 'objectBoundingBox') {
+        ctx.warnings.push('a clipPath with clipPathUnits="objectBoundingBox" is not supported — the content is painted UNCLIPPED');
+        return null;
+    }
+    const ops = [];
+    for (const child of (_b = def.children) !== null && _b !== void 0 ? _b : []) {
+        if (!child || typeof child !== 'object')
+            continue;
+        const childOps = geometryOps(child, resolved(child, ctx));
+        if (childOps)
+            ops.push(...childOps);
+        if ((_c = child.props) === null || _c === void 0 ? void 0 : _c['transform']) {
+            ctx.warnings.push('a transform on a clipPath child is ignored — the untransformed shape clips');
+        }
+    }
+    return ops.length > 0 ? ops : 'hide';
+}
+function isIdentity(m) {
+    return m.a === 1 && m.b === 0 && m.c === 0 && m.d === 1 && m.e === 0 && m.f === 0;
+}
+/** A `url(#…)` reference's target id, or null. */
+function urlRefId(value) {
+    if (typeof value !== 'string')
+        return null;
+    const ref = /^url\(#([^)]+)\)$/.exec(value.trim());
+    return ref ? ref[1] : null;
+}
+/**
+ * Resolve a paint value to a FLAT colour, degrading paint servers with a warning.
+ *
+ * This is the fallback path only: gradient FILLS on shapes render as real shadings and
+ * never come through here. What does: gradient strokes, gradient-filled text, and
+ * patterns — each flattened to its most honest stand-in colour, each warned with the
+ * caller's own reason (`why`), so the fidelity report says exactly what degraded.
+ */
+function flattenedPaint(value, ctx, why) {
+    var _a, _b;
+    const id = urlRefId(value);
+    if (id === null)
+        return (0, pdf_primitives_1.parsePdfColor)(value);
+    const gradient = ctx.defs.gradients.get(id);
+    if (gradient) {
+        ctx.warnings.push(why);
+        return gradient.stops[0].color;
+    }
+    const pattern = ctx.defs.patterns.get(id);
+    if (pattern) {
+        // The most honest stand-in for a pattern is the field its marks sit on — its
+        // background rect's fill, when it has one.
+        ctx.warnings.push('a pattern paint was flattened to its background colour — PDF tiling patterns are not implemented');
+        for (const child of (_a = pattern.children) !== null && _a !== void 0 ? _a : []) {
+            const color = (0, pdf_primitives_1.parsePdfColor)((_b = child === null || child === void 0 ? void 0 : child.props) === null || _b === void 0 ? void 0 : _b['fill']);
+            if ((child === null || child === void 0 ? void 0 : child.type) === 'rect' && color)
+                return color;
+        }
+        return null;
+    }
+    ctx.warnings.push(`a paint references "url(#${id})", which is not in the tree — not painted`);
+    return null;
+}
+const COLOR_CHANNELS = s => [s.color.r, s.color.g, s.color.b];
+/** Stop alpha as DeviceGray luminosity: 1 → white (keep), 0 → black (mask away). */
+const ALPHA_CHANNELS = s => [s.alpha];
+/** Type 2 (exponential) function between two stops — PDF's native two-value ramp. */
+function rampFunction(from, to, channels) {
+    const c = (s) => `[${channels(s).map(pdf_primitives_1.num).join(' ')}]`;
+    return `<< /FunctionType 2 /Domain [0 1] /C0 ${c(from)} /C1 ${c(to)} /N 1 >>`;
+}
+/** 2 stops → one Type 2; more → a Type 3 stitching of Type 2 ramps at the stop offsets. */
+function shadingFunction(stops, channels) {
+    // Pad the domain: SVG pads before the first and after the last stop with their colours.
+    const padded = [...stops];
+    if (padded[0].offset > 0)
+        padded.unshift(Object.assign(Object.assign({}, padded[0]), { offset: 0 }));
+    if (padded[padded.length - 1].offset < 1)
+        padded.push(Object.assign(Object.assign({}, padded[padded.length - 1]), { offset: 1 }));
+    if (padded.length === 1)
+        padded.push(Object.assign(Object.assign({}, padded[0]), { offset: 1 }));
+    if (padded.length === 2)
+        return rampFunction(padded[0], padded[1], channels);
+    // /Bounds must ascend strictly inside (0,1) — two stops at one offset (a hard colour
+    // break) become an epsilon-wide ramp, which is what it looks like at any zoom.
+    const bounds = [];
+    let previous = 0;
+    for (let i = 1; i < padded.length - 1; i++) {
+        const bound = Math.min(Math.max(padded[i].offset, previous + 0.0001), 0.9999);
+        bounds.push(bound);
+        previous = bound;
+    }
+    const functions = [];
+    for (let i = 0; i < padded.length - 1; i++)
+        functions.push(rampFunction(padded[i], padded[i + 1], channels));
+    return (`<< /FunctionType 3 /Domain [0 1] /Functions [${functions.join(' ')}] ` +
+        `/Bounds [${bounds.map(pdf_primitives_1.num).join(' ')}] /Encode [${functions.map(() => '0 1').join(' ')}] >>`);
+}
+/**
+ * The shading dicts for a gradient as used by ONE element (objectBoundingBox coords
+ * depend on the element's box), or null when the box cannot be determined.
+ */
+function shadingDictFor(gradient, vnode, ctx) {
+    let geometry;
+    if (gradient.kind === 'linear') {
+        let { x1, y1, x2, y2 } = gradient.coords;
+        if (gradient.objectBoundingBox) {
+            const box = (0, bounds_1.vnodeBounds)(vnode);
+            if (!box)
+                return null;
+            x1 = box.x + x1 * box.width;
+            y1 = box.y + y1 * box.height;
+            x2 = box.x + x2 * box.width;
+            y2 = box.y + y2 * box.height;
+        }
+        geometry = `/ShadingType 2 /ColorSpace {CS} /Coords [${(0, pdf_primitives_1.num)(x1)} ${(0, pdf_primitives_1.num)(y1)} ${(0, pdf_primitives_1.num)(x2)} ${(0, pdf_primitives_1.num)(y2)}]`;
+    }
+    else {
+        let { cx, cy, r } = gradient.coords;
+        if (gradient.objectBoundingBox) {
+            const box = (0, bounds_1.vnodeBounds)(vnode);
+            if (!box)
+                return null;
+            cx = box.x + cx * box.width;
+            cy = box.y + cy * box.height;
+            // SVG's oBB radius against a non-square box is an ellipse (via gradientTransform);
+            // the normalised diagonal is the spec's own circle-equivalent and the honest circle.
+            r = r * (Math.hypot(box.width, box.height) / Math.SQRT2);
+        }
+        // PDF radial coords are [x0 y0 r0 x1 y1 r1]: inner circle (SVG's focal, radius 0) to
+        // the outer circle. The capture emits no focal point, so it sits at the centre.
+        geometry = `/ShadingType 3 /ColorSpace {CS} /Coords [${(0, pdf_primitives_1.num)(cx)} ${(0, pdf_primitives_1.num)(cy)} 0 ${(0, pdf_primitives_1.num)(cx)} ${(0, pdf_primitives_1.num)(cy)} ${(0, pdf_primitives_1.num)(r)}]`;
+    }
+    // /Extend [true true] = SVG's default spreadMethod="pad": both ends run on.
+    const dict = (cs, channels) => `<< ${geometry.replace('{CS}', cs)} /Function ${shadingFunction(gradient.stops, channels)} /Extend [true true] >>`;
+    const color = dict('/DeviceRGB', COLOR_CHANNELS);
+    // Translucent stops → a luminosity soft mask painting the SAME geometry as a gray
+    // alpha ramp. The mask form's /BBox must cover everything the colour shading can
+    // reach (the element, since the sh is clipped to it) — outside the BBox the mask's
+    // BLACK backdrop rules, i.e. alpha 0, so an under-sized box eats the element's edge.
+    if (gradient.stops.some(stop => stop.alpha < 1)) {
+        const box = (0, bounds_1.vnodeBounds)(vnode);
+        if (!box) {
+            ctx.warnings.push('a gradient with stop opacity is painted OPAQUE — its soft-mask form needs an element ' +
+                'bounding box that could not be determined');
+            return { color, mask: null };
+        }
+        const pad = 8; // anti-aliasing head-room; the shape clip bounds the real paint anyway
+        const bbox = `${(0, pdf_primitives_1.num)(box.x - pad)} ${(0, pdf_primitives_1.num)(box.y - pad)} ` +
+            `${(0, pdf_primitives_1.num)(box.x + box.width + pad)} ${(0, pdf_primitives_1.num)(box.y + box.height + pad)}`;
+        return { color, mask: { shading: dict('/DeviceGray', ALPHA_CHANNELS), bbox } };
+    }
+    return { color, mask: null };
+}
+function drawElement(vnode, style, stream, ctx) {
+    if (vnode.type === 'text') {
+        drawText(vnode, style, stream, ctx);
+        return;
+    }
+    if (vnode.type === 'image') {
+        drawImage(style, stream, ctx);
+        return;
+    }
+    const ops = geometryOps(vnode, style);
+    if (!ops || ops.length === 0)
+        return;
+    // A gradient FILL gets a real shading; everything else resolves to a flat colour.
+    const fillId = urlRefId(style['fill']);
+    const gradient = fillId ? ctx.defs.gradients.get(fillId) : undefined;
+    let shadingName = null;
+    let softMaskName = null;
+    let fill = null;
+    if (gradient) {
+        const shading = shadingDictFor(gradient, vnode, ctx);
+        if (shading) {
+            shadingName = ctx.shadings.nameFor(shading.color);
+            if (shading.mask)
+                softMaskName = ctx.softMasks.nameFor(shading.mask.shading, shading.mask.bbox);
+        }
+        else {
+            ctx.warnings.push('a gradient fill was flattened to its first stop — its objectBoundingBox coords need an ' +
+                'element bounding box that could not be determined');
+            fill = gradient.stops[0].color;
+        }
+    }
+    else {
+        // The gradient branch above is the only gradient path, so the `why` here can only
+        // ever fire for patterns / dangling refs, which carry their own messages.
+        fill = flattenedPaint(style['fill'], ctx, 'a gradient fill was flattened to its first stop');
+    }
+    const stroke = flattenedPaint(style['stroke'], ctx, 'a gradient STROKE was flattened to its first stop — painting a shading through a stroke ' +
+        'needs the stroke outline as a clipping path, which this exporter does not build');
+    // `1px` is a legal CSS width and `Number('1px')` is NaN — parseFloat, not Number.
+    const strokeWidth = len(style['stroke-width'], 1);
+    const willFill = fill !== null;
+    const willStroke = stroke !== null && strokeWidth > 0;
+    if (!shadingName && !willFill && !willStroke)
+        return;
+    const alpha = nn(style['opacity'], 1) *
+        nn(style['fill-opacity'], 1) *
+        (fill ? (0, pdf_primitives_1.parseColorAlpha)(style['fill']) : 1);
+    if (shadingName) {
+        // Clip to the shape, paint the shading, pop. The clip is why W n precedes sh.
+        // The soft-mask gs (stop opacity) comes FIRST: the mask form's coordinate space is
+        // fixed at gs time, and it must be the same current user space the sh paints in.
+        // The matching Q resets the SMask — nothing after this block stays masked.
+        stream.save();
+        if (softMaskName)
+            stream.push(`/${softMaskName} gs`);
+        if (alpha < 1)
+            stream.setAlpha(Math.max(0, alpha));
+        for (const op of ops)
+            stream.push(op);
+        stream.push('W n');
+        stream.push(`/${shadingName} sh`);
+        stream.restore();
+        if (willStroke) {
+            // Second pass: the shading consumed the path as its clip, so stroke a fresh one.
+            const strokeAlpha = nn(style['opacity'], 1);
+            stream.save();
+            if (strokeAlpha < 1)
+                stream.setAlpha(Math.max(0, strokeAlpha));
+            stream.setStroke(stroke);
+            stream.setLineWidth(strokeWidth);
+            stream.setDash(normaliseDash(style['stroke-dasharray']));
+            for (const op of ops)
+                stream.push(op);
+            stream.push('S');
+            stream.restore();
+        }
+        return;
+    }
+    stream.save();
+    if (alpha < 1)
+        stream.setAlpha(Math.max(0, alpha));
+    if (fill)
+        stream.setFill(fill);
+    if (stroke && willStroke) {
+        stream.setStroke(stroke);
+        stream.setLineWidth(strokeWidth);
+        stream.setDash(normaliseDash(style['stroke-dasharray']));
+    }
+    for (const op of ops)
+        stream.push(op);
+    // B = fill then stroke; f = fill; S = stroke.
+    stream.push(willFill && willStroke ? 'B' : willFill ? 'f' : 'S');
+    stream.restore();
+}
+/**
+ * An <image> → its XObject invocation: `q`, a placement `cm`, `Do`, `Q`.
+ *
+ * The placement matrix is [w 0 0 -h x y+h]: Do paints the unit square with (0,0) at the
+ * image's BOTTOM-left, while the page CTM is y-down SVG space — the -h re-flips so the
+ * top pixel row lands at y, not upside down at y+h.
+ */
+function drawImage(style, stream, ctx) {
+    var _a;
+    const href = (_a = style['href']) !== null && _a !== void 0 ? _a : style['xlink:href'];
+    if (typeof href !== 'string' || href.trim() === '')
+        return;
+    const entry = ctx.images.resolve(href, message => ctx.warnings.push(message));
+    if (!entry)
+        return; // refused and already warned (external URL, interlaced, corrupt…)
+    const width = len(style['width'], entry.image.width);
+    const height = len(style['height'], entry.image.height);
+    if (width <= 0 || height <= 0)
+        return;
+    const alpha = nn(style['opacity'], 1);
+    stream.save();
+    if (alpha < 1)
+        stream.setAlpha(Math.max(0, alpha));
+    stream.concat({ a: width, b: 0, c: 0, d: -height, e: len(style['x']), f: len(style['y']) + height });
+    stream.push(`/${entry.name} Do`);
+    stream.restore();
+}
+/**
+ * A CSS length → number. `parseFloat`, because the flattener emits real CSS values and
+ * `stroke-width: 1px` is one of them — `Number('1px')` is NaN, which would silently turn
+ * every themed stroke into width 0 (i.e. invisible links).
+ */
+function len(value, fallback = 0) {
+    if (typeof value === 'number')
+        return Number.isFinite(value) ? value : fallback;
+    if (typeof value !== 'string')
+        return fallback;
+    const parsed = Number.parseFloat(value);
+    return Number.isFinite(parsed) ? parsed : fallback;
+}
+/** `"5,5"` / `"5 5"` → `"5 5"` (PDF wants a space-separated array). */
+function normaliseDash(value) {
+    if (typeof value !== 'string' || value.trim() === '' || value.trim() === 'none')
+        return null;
+    const parts = value
+        .split(/[\s,]+/)
+        .map(Number)
+        .filter(n => Number.isFinite(n) && n >= 0);
+    return parts.length ? parts.map(pdf_primitives_1.num).join(' ') : null;
+}
+function geometryOps(vnode, style) {
+    switch (vnode.type) {
+        case 'rect':
+            return (0, pdf_path_1.pdfRect)(len(style['x']), len(style['y']), len(style['width']), len(style['height']), len(style['rx']), len(style['ry']));
+        case 'circle': {
+            const r = len(style['r']);
+            return r > 0 ? (0, pdf_path_1.pdfCircle)(len(style['cx']), len(style['cy']), r) : null;
+        }
+        case 'ellipse':
+            return (0, pdf_path_1.pdfEllipse)(len(style['cx']), len(style['cy']), len(style['rx']), len(style['ry']));
+        case 'line':
+            return (0, pdf_path_1.pdfLine)(len(style['x1']), len(style['y1']), len(style['x2']), len(style['y2']));
+        case 'polygon':
+        case 'polyline':
+            return (0, pdf_path_1.pdfPoly)(style['points'], vnode.type === 'polygon');
+        case 'path': {
+            const d = style['d'];
+            return typeof d === 'string' && d.trim() !== '' ? (0, pdf_path_1.svgPathToPdf)(d) : null;
+        }
+        default:
+            return null; // g, svg, tspan: containers, no geometry of their own
+    }
+}
+function parsePoints(points) {
+    if (typeof points !== 'string')
+        return [];
+    const nums = points.trim().split(/[\s,]+/).map(Number).filter(n => Number.isFinite(n));
+    const out = [];
+    for (let i = 0; i + 1 < nums.length; i += 2)
+        out.push([nums[i], nums[i + 1]]);
+    return out;
+}
+/**
+ * Real PDF text: `BT … Tj … ET`. Selectable, searchable, copy-pasteable.
+ *
+ * The one fiddly bit is the TEXT MATRIX. The page CTM flips y (PDF is y-up, SVG is
+ * y-down), and text drawn under that flip would come out MIRRORED. So the text matrix
+ * un-flips locally — `1 0 0 -1 x y` — which puts the glyphs upright at the right place.
+ */
+function drawText(vnode, style, stream, ctx) {
+    var _a, _b, _c;
+    const content = textContentOf(vnode);
+    if (!content.trim())
+        return;
+    // `font-size: 14px` — parseFloat, not Number (see `len`).
+    const fontSize = len(style['font-size'], 12);
+    if (fontSize <= 0)
+        return;
+    const font = (0, pdf_primitives_1.pickBaseFont)(style['font-family'], style['font-weight'], style['font-style']);
+    const fillValue = (_a = style['fill']) !== null && _a !== void 0 ? _a : style['color'];
+    const anchor = String((_b = style['text-anchor']) !== null && _b !== void 0 ? _b : 'start');
+    const x = len(style['x']);
+    const y = len(style['y']);
+    const lines = content.split('\n');
+    const opacity = nn(style['opacity'], 1) * nn(style['fill-opacity'], 1);
+    // A gradient-filled text gets the REAL gradient: text rendering mode 7 adds the glyph
+    // outlines to the CLIP path at ET, and the shading is then painted through them —
+    // the same clipped-sh technique shapes use, with glyphs for geometry.
+    const gradientId = urlRefId(fillValue);
+    const gradient = gradientId ? ctx.defs.gradients.get(gradientId) : undefined;
+    const shading = gradient ? shadingDictFor(gradient, vnode, ctx) : null;
+    const emitLine = (line, index) => {
+        const encoded = (0, pdf_primitives_1.encodeWinAnsi)(line);
+        if (encoded.unsupported.length > 0) {
+            ctx.warnings.push(`text "${line}" contains characters the PDF base-14 fonts cannot encode ` +
+                `(${[...new Set(encoded.unsupported)].join('')}) — they are replaced with '?'. ` +
+                `Embedding a font that covers them would need a font subsetter, which this exporter does not have.`);
+        }
+        const width = (0, pdf_primitives_1.measureBaseFont)(font, line, fontSize);
+        const left = anchor === 'middle' ? x - width / 2 : anchor === 'end' ? x - width : x;
+        const lineY = y + index * fontSize;
+        // Un-flip: the page CTM has d = -scale, so without this the glyphs render upside down.
+        stream.push(`1 0 0 -1 ${(0, pdf_primitives_1.num)(left)} ${(0, pdf_primitives_1.num)(lineY)} Tm`);
+        stream.push(`${(0, pdf_primitives_1.pdfString)(encoded.bytes)} Tj`);
+    };
+    if (shading) {
+        const shadingName = ctx.shadings.nameFor(shading.color);
+        const softMaskName = shading.mask
+            ? ctx.softMasks.nameFor(shading.mask.shading, shading.mask.bbox)
+            : null;
+        stream.save();
+        // Mask gs first — its coordinate space is fixed at gs time (see drawElement).
+        if (softMaskName)
+            stream.push(`/${softMaskName} gs`);
+        if (opacity < 1)
+            stream.setAlpha(Math.max(0, opacity));
+        stream.setFont(font, fontSize);
+        // ONE BT/ET for every line: each ET intersects the block's accumulated outlines with
+        // the current clip, so per-line blocks would intersect line 1's clip with line 2's —
+        // empty — and the gradient would paint nothing.
+        stream.push('BT');
+        stream.push('7 Tr'); // mode 7: add to clip, paint nothing
+        lines.forEach(emitLine);
+        stream.push('ET');
+        stream.push(`/${shadingName} sh`);
+        // Q restores both the clip and text mode 0 for whatever paints next.
+        stream.restore();
+        return;
+    }
+    // Reached with a gradient only when shadingDictFor failed (no bounding box for its
+    // objectBoundingBox coords) — the honest degrade is first stop, said out loud.
+    const fill = (_c = flattenedPaint(fillValue, ctx, 'a gradient fill on text was flattened to its first stop — its objectBoundingBox coords ' +
+        'need an element bounding box that could not be determined')) !== null && _c !== void 0 ? _c : { r: 0, g: 0, b: 0 };
+    stream.save();
+    if (opacity < 1)
+        stream.setAlpha(Math.max(0, opacity));
+    stream.setFill(fill);
+    stream.setFont(font, fontSize);
+    lines.forEach((line, index) => {
+        stream.push('BT');
+        emitLine(line, index);
+        stream.push('ET');
+    });
+    stream.restore();
+}
+function textContentOf(vnode) {
+    var _a, _b;
+    const own = (_a = vnode.props) === null || _a === void 0 ? void 0 : _a['textContent'];
+    if (typeof own === 'string' && own !== '')
+        return own;
+    const lines = [];
+    for (const child of (_b = vnode.children) !== null && _b !== void 0 ? _b : []) {
+        if (typeof child === 'string') {
+            lines.push(child);
+        }
+        else if (child && typeof child === 'object') {
+            const nested = textContentOf(child);
+            if (nested)
+                lines.push(nested);
+        }
+    }
+    return lines.join('\n');
+}
+/** "3 / 7", centred in the bottom margin. Drawn OUTSIDE the clipped content area. */
+function paintPageNumber(stream, page, total, size, margins) {
+    const label = `${page} / ${total}`;
+    const fontSize = 9;
+    const width = (0, pdf_primitives_1.measureBaseFont)('Helvetica', label, fontSize);
+    stream.save();
+    stream.setFill({ r: 0.4, g: 0.4, b: 0.4 });
+    stream.setFont('Helvetica', fontSize);
+    stream.push('BT');
+    stream.push(`${(0, pdf_primitives_1.num)((size.width - width) / 2)} ${(0, pdf_primitives_1.num)(Math.max(12, margins.bottom / 2))} Td`);
+    stream.push(`${(0, pdf_primitives_1.pdfString)((0, pdf_primitives_1.encodeWinAnsi)(label).bytes)} Tj`);
+    stream.push('ET');
+    stream.restore();
+}
+function dedupe(warnings) {
+    return [...new Set(warnings)];
+}
+//# sourceMappingURL=pdf-export.js.map