ngx-pdf-export 0.0.1

package/fesm2022/ngx-pdf-export.mjs

@@ -0,0 +1,2028 @@
+import * as i0 from '@angular/core';
+import { ElementRef, Injectable, HostListener, Input, Directive } from '@angular/core';
+import { StandardFonts, PDFDocument, rgb, pushGraphicsState, moveTo, lineTo, closePath, clip, endPath, popGraphicsState } from 'pdf-lib';
+import fontkit from '@pdf-lib/fontkit';
+
+/**
+ * Unit conversions. See docs/architecture.md "Coordinate systems and units".
+ * Internal layout space is always PDF points (pt); DOM space is CSS px.
+ */
+const PX_TO_PT = 72 / 96;
+const PT_TO_PX = 96 / 72;
+const MM_TO_PT = 72 / 25.4;
+const PT_TO_MM = 25.4 / 72;
+function pxToPt(px) {
+    return px * PX_TO_PT;
+}
+function ptToPx(pt) {
+    return pt * PT_TO_PX;
+}
+function mmToPt(mm) {
+    return mm * MM_TO_PT;
+}
+function ptToMm(pt) {
+    return pt * PT_TO_MM;
+}
+/** Standard page sizes in points, portrait orientation. */
+const STANDARD_PAGE_SIZES_PT = {
+    A4: { widthPt: mmToPt(210), heightPt: mmToPt(297) },
+    A3: { widthPt: mmToPt(297), heightPt: mmToPt(420) },
+    Letter: { widthPt: 612, heightPt: 792 },
+    Legal: { widthPt: 612, heightPt: 1008 },
+};
+
+const RGBA_RE = /^rgba?\(\s*([\d.]+)\s*,\s*([\d.]+)\s*,\s*([\d.]+)\s*(?:,\s*([\d.]+)\s*)?\)$/i;
+/**
+ * Parses a getComputedStyle() color string. getComputedStyle always
+ * normalizes to rgb()/rgba() form in every browser we target, so we don't
+ * need to handle hex/hsl/named colors here.
+ */
+function parseComputedColor(value) {
+    if (!value) {
+        return undefined;
+    }
+    if (value === 'transparent') {
+        return { r: 0, g: 0, b: 0, a: 0 };
+    }
+    const match = RGBA_RE.exec(value.trim());
+    if (!match) {
+        return undefined;
+    }
+    return {
+        r: clamp255(Number(match[1])),
+        g: clamp255(Number(match[2])),
+        b: clamp255(Number(match[3])),
+        a: match[4] !== undefined ? clamp01$1(Number(match[4])) : 1,
+    };
+}
+function isTransparent(color) {
+    return !color || color.a <= 0;
+}
+function clamp255(n) {
+    return Math.max(0, Math.min(255, Math.round(n)));
+}
+function clamp01$1(n) {
+    return Math.max(0, Math.min(1, n));
+}
+
+function readBoxPaint(style) {
+    const backgroundColor = parseComputedColor(style.backgroundColor);
+    const opacity = clamp01(parseFloat(style.opacity || '1'));
+    const paint = {
+        opacity: Number.isFinite(opacity) ? opacity : 1,
+    };
+    if (backgroundColor && !isTransparent(backgroundColor)) {
+        paint.backgroundColor = backgroundColor;
+    }
+    const borders = readBorders(style);
+    if (borders) {
+        paint.borders = borders;
+    }
+    const radius = readBorderRadius(style);
+    if (radius) {
+        paint.borderRadius = radius;
+    }
+    return paint;
+}
+function readBorders(style) {
+    const top = readEdge(style, 'Top');
+    const right = readEdge(style, 'Right');
+    const bottom = readEdge(style, 'Bottom');
+    const left = readEdge(style, 'Left');
+    const hasAny = [top, right, bottom, left].some((e) => e.style !== 'none' && e.widthPt > 0);
+    if (!hasAny) {
+        return undefined;
+    }
+    return { top, right, bottom, left };
+}
+function readEdge(style, side) {
+    const widthPx = parseFloat(style[`border${side}Width`] || '0');
+    const borderStyle = normalizeBorderStyle(style[`border${side}Style`]);
+    const color = parseComputedColor(style[`border${side}Color`]) ?? { r: 0, g: 0, b: 0, a: 1 };
+    return {
+        widthPt: borderStyle === 'none' ? 0 : pxToPt(widthPx || 0),
+        style: borderStyle,
+        color,
+    };
+}
+function normalizeBorderStyle(value) {
+    switch (value) {
+        case 'dashed':
+            return 'dashed';
+        case 'dotted':
+            return 'dotted';
+        case 'solid':
+        case 'double':
+        case 'groove':
+        case 'ridge':
+        case 'inset':
+        case 'outset':
+            return 'solid';
+        default:
+            return 'none';
+    }
+}
+function readBorderRadius(style) {
+    const topLeft = pxToPt(parseFloat(style.borderTopLeftRadius || '0'));
+    const topRight = pxToPt(parseFloat(style.borderTopRightRadius || '0'));
+    const bottomRight = pxToPt(parseFloat(style.borderBottomRightRadius || '0'));
+    const bottomLeft = pxToPt(parseFloat(style.borderBottomLeftRadius || '0'));
+    if (!topLeft && !topRight && !bottomRight && !bottomLeft) {
+        return undefined;
+    }
+    return { topLeft, topRight, bottomRight, bottomLeft };
+}
+function clamp01(n) {
+    return Math.max(0, Math.min(1, n));
+}
+
+/**
+ * Framework-independent internal document/layout tree.
+ * See docs/architecture.md and docs/layout-engine.md.
+ *
+ * All geometry on these nodes is in *layout space*: PDF points, y-down,
+ * origin at the top-left of the captured root element (a single tall
+ * "flow" -- pagination has not happened yet at this stage).
+ */
+const DEFAULT_BREAK_RULES = {
+    breakInside: 'auto',
+    breakBefore: 'auto',
+    breakAfter: 'auto',
+};
+function isContainer(node) {
+    return node.type === 'block' || node.type === 'group';
+}
+
+/**
+ * Resolves break-inside/before/after from computed style, plus an optional
+ * caller-supplied `keepTogether` selector list matched against the live
+ * element (checked by the caller via `element.matches(selector)`).
+ * See docs/pagination.md "keepTogether / break controls".
+ */
+function readBreakRules(style, forceKeepTogether) {
+    const breakInside = normalizeAvoid(style.breakInside) || normalizeAvoid(style.pageBreakInside);
+    const breakBefore = normalizePage(style.breakBefore) || normalizePage(style.pageBreakBefore);
+    const breakAfter = normalizePage(style.breakAfter) || normalizePage(style.pageBreakAfter);
+    return {
+        breakInside: forceKeepTogether || breakInside === 'avoid' ? 'avoid' : 'auto',
+        breakBefore: breakBefore === 'page' ? 'page' : 'auto',
+        breakAfter: breakAfter === 'page' ? 'page' : 'auto',
+    };
+}
+function normalizeAvoid(value) {
+    return value === 'avoid' ? 'avoid' : undefined;
+}
+function normalizePage(value) {
+    return value === 'page' || value === 'always' || value === 'left' || value === 'right' ? 'page' : undefined;
+}
+
+function extractTextRuns(textNode) {
+    const data = textNode.data;
+    if (!data || !/\S/.test(data)) {
+        return [];
+    }
+    const range = document.createRange();
+    range.selectNodeContents(textNode);
+    const lineRects = Array.from(range.getClientRects()).filter((r) => r.width > 0 && r.height > 0);
+    if (lineRects.length <= 1) {
+        const rect = lineRects[0] ?? textNode.parentElement?.getBoundingClientRect();
+        return rect ? [{ text: data, rect }] : [];
+    }
+    const boundaries = [0];
+    for (let lineIndex = 0; lineIndex < lineRects.length - 1; lineIndex++) {
+        const target = lineIndex + 2;
+        const prev = boundaries[boundaries.length - 1];
+        const k = findLineBoundary(range, textNode, data.length, target, prev);
+        boundaries.push(Math.max(prev, k - 1));
+    }
+    boundaries.push(data.length);
+    const runs = [];
+    for (let i = 0; i < lineRects.length; i++) {
+        const start = boundaries[i];
+        const end = boundaries[i + 1];
+        const text = data.slice(start, end);
+        if (text.trim().length === 0 && text.length === 0) {
+            continue;
+        }
+        runs.push({ text, rect: lineRects[i] });
+    }
+    return runs;
+}
+function countLinesForPrefix(range, node, k) {
+    range.setStart(node, 0);
+    range.setEnd(node, k);
+    return range.getClientRects().length;
+}
+/** Minimal k in (prev, maxLen] such that the prefix [0, k) spans >= target lines. */
+function findLineBoundary(range, node, maxLen, target, prev) {
+    let low = prev + 1;
+    let high = maxLen;
+    while (low < high) {
+        const mid = Math.floor((low + high) / 2);
+        if (countLinesForPrefix(range, node, mid) >= target) {
+            high = mid;
+        }
+        else {
+            low = mid + 1;
+        }
+    }
+    return low;
+}
+
+const GRADIENT_RE = /(linear|radial|conic)-gradient\(/i;
+function checkUnsupported(style) {
+    const backgroundImage = style.backgroundImage;
+    if (backgroundImage && backgroundImage !== 'none' && GRADIENT_RE.test(backgroundImage)) {
+        return { unsupported: true, reason: `background: ${backgroundImage} is a gradient and is not supported; rasterized.` };
+    }
+    const boxShadow = style.boxShadow;
+    if (boxShadow && boxShadow !== 'none') {
+        return { unsupported: true, reason: `box-shadow: ${boxShadow} is not supported; rasterized.` };
+    }
+    const filter = style.filter;
+    if (filter && filter !== 'none') {
+        return { unsupported: true, reason: `filter: ${filter} is not supported; rasterized.` };
+    }
+    const backdropFilter = style.backdropFilter;
+    if (backdropFilter && backdropFilter !== 'none') {
+        return { unsupported: true, reason: `backdrop-filter is not supported; rasterized.` };
+    }
+    const transform = style.transform;
+    if (transform && transform !== 'none' && !isTranslateOnly(transform)) {
+        return { unsupported: true, reason: `transform: ${transform} is not supported (only translate() is); rasterized.` };
+    }
+    const mixBlendMode = style.mixBlendMode;
+    if (mixBlendMode && mixBlendMode !== 'normal') {
+        return { unsupported: true, reason: `mix-blend-mode: ${mixBlendMode} is not supported; rasterized.` };
+    }
+    if (style.display === 'grid' || style.display === 'inline-grid') {
+        return { unsupported: true, reason: 'display: grid is not specially interpreted and is rasterized as a unit.' };
+    }
+    return { unsupported: false };
+}
+function isTranslateOnly(transform) {
+    // matrix(1, 0, 0, 1, tx, ty) is what getComputedStyle reports for a pure translate().
+    const m = /^matrix\(\s*1,\s*0,\s*0,\s*1,\s*[-\d.]+,\s*[-\d.]+\s*\)$/i;
+    return m.test(transform.trim());
+}
+
+/**
+ * Rewrites the numeric coordinates in an SVG path `d` string by a scale
+ * factor, so a path authored in the SVG's own viewBox units can be
+ * embedded directly in PDF point space without a separate transform.
+ *
+ * This is a generic tokenizer for well-formed path data (commands
+ * separated from numbers, numbers separated by whitespace/commas). It
+ * does not handle the rare "arc flags packed with no separator" shorthand
+ * (e.g. `A5 5 0 01 1 10 10`) some minifiers produce -- documented in
+ * docs/css-support.md.
+ */
+const COMMAND_RE = /[MLHVCSQTAZmlhvcsqtaz]/;
+const NUMBER_RE = /[-+]?(?:\d+\.\d+|\.\d+|\d+)(?:[eE][-+]?\d+)?/g;
+// Number of coordinate values per command letter, and which of those are
+// x-like vs y-like (for independent sx/sy scaling). 'f' = flag (unscaled).
+const PARAM_ROLES = {
+    M: ['x', 'y'],
+    L: ['x', 'y'],
+    T: ['x', 'y'],
+    H: ['x'],
+    V: ['y'],
+    C: ['x', 'y', 'x', 'y', 'x', 'y'],
+    S: ['x', 'y', 'x', 'y'],
+    Q: ['x', 'y', 'x', 'y'],
+    A: ['x', 'y', 'f', 'f', 'f', 'x', 'y'],
+    Z: [],
+};
+function scalePathData(d, sx, sy) {
+    let out = '';
+    let i = 0;
+    let currentRoles = [];
+    let roleIndex = 0;
+    while (i < d.length) {
+        const ch = d[i];
+        if (COMMAND_RE.test(ch)) {
+            out += ch;
+            currentRoles = PARAM_ROLES[ch.toUpperCase()] ?? [];
+            roleIndex = 0;
+            i++;
+            continue;
+        }
+        if (/\s|,/.test(ch)) {
+            out += ch;
+            i++;
+            continue;
+        }
+        NUMBER_RE.lastIndex = i;
+        const match = NUMBER_RE.exec(d);
+        if (!match || match.index !== i) {
+            // Unrecognized character; copy through unchanged rather than throw.
+            out += ch;
+            i++;
+            continue;
+        }
+        const raw = match[0];
+        const value = Number(raw);
+        const role = currentRoles.length ? currentRoles[roleIndex % currentRoles.length] : 'x';
+        roleIndex++;
+        const scaled = role === 'y' ? value * sy : role === 'x' ? value * sx : value;
+        out += formatNumber(scaled);
+        i += raw.length;
+    }
+    return out;
+}
+function formatNumber(n) {
+    const rounded = Math.round(n * 1000) / 1000;
+    return String(rounded);
+}
+
+const SUPPORTED_TAGS = new Set(['rect', 'circle', 'ellipse', 'line', 'polyline', 'polygon', 'path', 'g', 'svg']);
+/**
+ * Parses a supported subset of SVG into scale-normalized draw commands.
+ * Returns null if the subtree uses a feature we don't translate (gradient
+ * fill, <text>, <use>, <clipPath>, filters, patterns, images) -- the
+ * caller falls back to rasterizing the whole <svg> as one element. See
+ * docs/css-support.md.
+ */
+function parseSvg(svg, renderedWidthPt, renderedHeightPt) {
+    const viewBox = svg.viewBox?.baseVal;
+    const vbWidth = viewBox && viewBox.width > 0 ? viewBox.width : svg.width.baseVal.value || renderedWidthPt;
+    const vbHeight = viewBox && viewBox.height > 0 ? viewBox.height : svg.height.baseVal.value || renderedHeightPt;
+    const vbX = viewBox?.x ?? 0;
+    const vbY = viewBox?.y ?? 0;
+    const sx = vbWidth > 0 ? renderedWidthPt / vbWidth : 1;
+    const sy = vbHeight > 0 ? renderedHeightPt / vbHeight : 1;
+    const commands = [];
+    const ok = walk(svg, sx, sy, vbX, vbY, commands);
+    return ok ? commands : null;
+}
+function walk(el, sx, sy, vbX, vbY, out) {
+    for (const child of Array.from(el.children)) {
+        const tag = child.tagName.toLowerCase();
+        if (!SUPPORTED_TAGS.has(tag)) {
+            return false;
+        }
+        if (tag === 'g' || tag === 'svg') {
+            if (!walk(child, sx, sy, vbX, vbY, out)) {
+                return false;
+            }
+            continue;
+        }
+        const style = getComputedStyle(child);
+        if (hasGradientOrPattern(style.fill) || hasGradientOrPattern(style.stroke)) {
+            return false;
+        }
+        const paint = readSvgPaint(style);
+        switch (tag) {
+            case 'rect': {
+                const r = child;
+                out.push({
+                    op: 'rect',
+                    x: (num(r, 'x') - vbX) * sx,
+                    y: (num(r, 'y') - vbY) * sy,
+                    width: num(r, 'width') * sx,
+                    height: num(r, 'height') * sy,
+                    rx: num(r, 'rx') * sx,
+                    ry: num(r, 'ry') * sy,
+                    paint,
+                });
+                break;
+            }
+            case 'circle': {
+                const c = child;
+                const rr = num(c, 'r');
+                out.push({
+                    op: 'ellipse',
+                    cx: (num(c, 'cx') - vbX) * sx,
+                    cy: (num(c, 'cy') - vbY) * sy,
+                    rx: rr * sx,
+                    ry: rr * sy,
+                    paint,
+                });
+                break;
+            }
+            case 'ellipse': {
+                const e = child;
+                out.push({
+                    op: 'ellipse',
+                    cx: (num(e, 'cx') - vbX) * sx,
+                    cy: (num(e, 'cy') - vbY) * sy,
+                    rx: num(e, 'rx') * sx,
+                    ry: num(e, 'ry') * sy,
+                    paint,
+                });
+                break;
+            }
+            case 'line': {
+                const l = child;
+                out.push({
+                    op: 'line',
+                    x1: (num(l, 'x1') - vbX) * sx,
+                    y1: (num(l, 'y1') - vbY) * sy,
+                    x2: (num(l, 'x2') - vbX) * sx,
+                    y2: (num(l, 'y2') - vbY) * sy,
+                    paint,
+                });
+                break;
+            }
+            case 'polyline':
+            case 'polygon': {
+                const points = (child.getAttribute('points') || '').trim();
+                if (!points)
+                    break;
+                const d = pointsToPathData(points, tag === 'polygon');
+                out.push({ op: 'path', d: scalePathData(offsetPathOrigin(d, vbX, vbY), sx, sy), paint });
+                break;
+            }
+            case 'path': {
+                const d = child.getAttribute('d') || '';
+                if (!d)
+                    break;
+                out.push({ op: 'path', d: scalePathData(d, sx, sy), paint });
+                break;
+            }
+        }
+    }
+    return true;
+}
+function hasGradientOrPattern(paintRef) {
+    return paintRef.startsWith('url(');
+}
+function readSvgPaint(style) {
+    const fillOpacity = parseFloat(style.fillOpacity || '1');
+    const strokeOpacity = parseFloat(style.strokeOpacity || '1');
+    const opacity = parseFloat(style.opacity || '1');
+    const fillColor = style.fill && style.fill !== 'none' ? withAlpha(parseComputedColor(style.fill), fillOpacity) : undefined;
+    const strokeColor = style.stroke && style.stroke !== 'none' ? withAlpha(parseComputedColor(style.stroke), strokeOpacity) : undefined;
+    return {
+        fill: fillColor,
+        stroke: strokeColor,
+        strokeWidthPt: pxToPt(parseFloat(style.strokeWidth || '0')),
+        opacity: Number.isFinite(opacity) ? opacity : 1,
+    };
+}
+function withAlpha(color, alphaMultiplier) {
+    if (!color)
+        return undefined;
+    return { ...color, a: color.a * (Number.isFinite(alphaMultiplier) ? alphaMultiplier : 1) };
+}
+function num(el, attr) {
+    const v = el[attr]?.baseVal?.value;
+    if (typeof v === 'number')
+        return v;
+    return parseFloat(el.getAttribute(attr) || '0') || 0;
+}
+function pointsToPathData(points, close) {
+    const coords = points.split(/[\s,]+/).filter(Boolean).map(Number);
+    let d = '';
+    for (let i = 0; i < coords.length - 1; i += 2) {
+        d += (i === 0 ? 'M' : 'L') + coords[i] + ' ' + coords[i + 1] + ' ';
+    }
+    return close ? d + 'Z' : d;
+}
+function offsetPathOrigin(d, vbX, vbY) {
+    if (!vbX && !vbY)
+        return d;
+    // Points already carry absolute coordinates; shift by viewBox origin using the same scaler with a translate pass.
+    return d.replace(/(-?\d+(?:\.\d+)?)\s+(-?\d+(?:\.\d+)?)/g, (_m, x, y) => `${Number(x) - vbX} ${Number(y) - vbY}`);
+}
+
+let idCounter = 0;
+function nextId(prefix) {
+    idCounter += 1;
+    return `${prefix}-${idCounter}`;
+}
+function inspectElement(root, options) {
+    const rootRect = root.getBoundingClientRect();
+    const assetTasks = [];
+    const warnings = [];
+    const children = walkChildren(root, rootRect, options, assetTasks, warnings);
+    return {
+        document: {
+            flowWidthPt: pxToPt(rootRect.width),
+            flowHeightPt: pxToPt(rootRect.height),
+            children,
+        },
+        assetTasks,
+        warnings,
+    };
+}
+function relativeRect(elRect, rootRect) {
+    return {
+        x: pxToPt(elRect.left - rootRect.left),
+        y: pxToPt(elRect.top - rootRect.top),
+        width: pxToPt(elRect.width),
+        height: pxToPt(elRect.height),
+    };
+}
+function walkChildren(parent, rootRect, options, assetTasks, warnings) {
+    const out = [];
+    for (const child of Array.from(parent.childNodes)) {
+        if (child.nodeType === Node.TEXT_NODE) {
+            out.push(...buildTextNodes(child, parent, rootRect));
+        }
+        else if (child.nodeType === Node.ELEMENT_NODE) {
+            const node = visitElement(child, rootRect, options, assetTasks, warnings);
+            if (node) {
+                out.push(node);
+            }
+        }
+    }
+    return out;
+}
+const SKIP_TAGS = new Set(['SCRIPT', 'STYLE', 'TEMPLATE', 'NOSCRIPT']);
+function visitElement(el, rootRect, options, assetTasks, warnings) {
+    if (SKIP_TAGS.has(el.tagName)) {
+        return null;
+    }
+    const style = getComputedStyle(el);
+    if (style.display === 'none') {
+        return null;
+    }
+    const elRect = el.getBoundingClientRect();
+    if (elRect.width <= 0 || elRect.height <= 0) {
+        return null;
+    }
+    const rect = relativeRect(elRect, rootRect);
+    const visible = style.visibility !== 'hidden' && parseFloat(style.opacity || '1') > 0;
+    const forceKeepTogether = options.keepTogetherSelectors.some((sel) => {
+        try {
+            return el.matches(sel);
+        }
+        catch {
+            return false;
+        }
+    });
+    const breakRules = readBreakRules(style, forceKeepTogether);
+    const tag = el.tagName.toLowerCase();
+    if (tag === 'img') {
+        return buildImageNode(el, rect, visible, breakRules, assetTasks);
+    }
+    if (tag === 'canvas') {
+        return buildCanvasNode(el, rect, visible, breakRules, assetTasks);
+    }
+    if (tag === 'svg') {
+        return buildSvgNode(el, rect, visible, breakRules, assetTasks, warnings);
+    }
+    if (tag === 'table') {
+        return buildTableNode(el, rootRect, rect, visible, breakRules, options, assetTasks, warnings);
+    }
+    const unsupported = checkUnsupported(style);
+    if (unsupported.unsupported) {
+        warnings.push({ message: unsupported.reason, elementDescription: describeElement$1(el) });
+        return buildFallbackImageNode(el, rect, visible, breakRules, unsupported.reason, assetTasks, elRect);
+    }
+    const paint = readBoxPaint(style);
+    const children = walkChildren(el, rootRect, options, assetTasks, warnings);
+    if (children.length === 0 && !paint.backgroundColor && !paint.borders) {
+        return null;
+    }
+    const clips = style.overflow !== 'visible' && (style.overflowX !== 'visible' || style.overflowY !== 'visible');
+    if (clips) {
+        const group = {
+            id: nextId('group'),
+            type: 'group',
+            rect,
+            visible,
+            break: breakRules,
+            paint,
+            children,
+            clip: true,
+        };
+        return group;
+    }
+    const node = {
+        id: nextId('block'),
+        type: 'block',
+        rect,
+        visible,
+        break: breakRules,
+        paint,
+        children,
+    };
+    return node;
+}
+function buildTextNodes(textNode, parentEl, rootRect) {
+    const raw = extractTextRuns(textNode);
+    if (raw.length === 0) {
+        return [];
+    }
+    const style = getComputedStyle(parentEl);
+    const font = readFont(style);
+    const color = parseComputedColor(style.color) ?? { r: 0, g: 0, b: 0, a: 1 };
+    const letterSpacingPt = style.letterSpacing === 'normal' ? 0 : pxToPt(parseFloat(style.letterSpacing || '0') || 0);
+    const align = normalizeAlign(style.textAlign, style.direction);
+    const decorationLine = style.textDecorationLine || style.textDecoration || '';
+    const decoration = {
+        underline: decorationLine.includes('underline'),
+        lineThrough: decorationLine.includes('line-through'),
+    };
+    return raw.map((run) => {
+        const rect = relativeRect(run.rect, rootRect);
+        return {
+            id: nextId('text'),
+            type: 'text',
+            rect,
+            visible: style.visibility !== 'hidden',
+            break: { breakInside: 'avoid', breakBefore: 'auto', breakAfter: 'auto' },
+            text: run.text,
+            font,
+            color,
+            letterSpacingPt,
+            align,
+            decoration,
+            baselineOffsetPt: rect.height * 0.8,
+        };
+    });
+}
+function readFont(style) {
+    const weight = parseInt(style.fontWeight || '400', 10) || (style.fontWeight === 'bold' ? 700 : 400);
+    const fontStyle = style.fontStyle === 'italic' || style.fontStyle === 'oblique' ? 'italic' : 'normal';
+    return {
+        family: (style.fontFamily || 'sans-serif').split(',')[0].trim().replace(/^["']|["']$/g, ''),
+        weight,
+        style: fontStyle,
+        sizePt: pxToPt(parseFloat(style.fontSize || '16')),
+    };
+}
+function normalizeAlign(textAlign, direction) {
+    const isRtl = direction === 'rtl';
+    switch (textAlign) {
+        case 'center':
+            return 'center';
+        case 'right':
+            return 'right';
+        case 'left':
+            return 'left';
+        case 'justify':
+            return 'justify';
+        case 'start':
+            return isRtl ? 'right' : 'left';
+        case 'end':
+            return isRtl ? 'left' : 'right';
+        default:
+            return 'left';
+    }
+}
+function buildImageNode(img, rect, visible, breakRules, assetTasks) {
+    const style = getComputedStyle(img);
+    const node = {
+        id: nextId('img'),
+        type: 'image',
+        rect,
+        visible,
+        break: breakRules,
+        source: { kind: 'url', value: '' },
+        fit: style.objectFit || 'fill',
+        naturalWidth: img.naturalWidth || img.width,
+        naturalHeight: img.naturalHeight || img.height,
+        isFallbackRaster: false,
+    };
+    assetTasks.push({ kind: 'img', node, element: img });
+    return node;
+}
+function buildCanvasNode(canvas, rect, visible, breakRules, assetTasks) {
+    const node = {
+        id: nextId('canvas'),
+        type: 'image',
+        rect,
+        visible,
+        break: breakRules,
+        source: { kind: 'canvas', value: '' },
+        fit: 'fill',
+        naturalWidth: canvas.width,
+        naturalHeight: canvas.height,
+        isFallbackRaster: false,
+    };
+    assetTasks.push({ kind: 'canvas', node, element: canvas });
+    return node;
+}
+function buildSvgNode(svg, rect, visible, breakRules, assetTasks, warnings) {
+    try {
+        const commands = parseSvg(svg, rect.width, rect.height);
+        if (commands) {
+            return {
+                id: nextId('svg'),
+                type: 'svg',
+                rect,
+                visible,
+                break: breakRules,
+                commands,
+                viewBox: rect,
+            };
+        }
+    }
+    catch {
+        // fall through to rasterization
+    }
+    warnings.push({ message: 'This <svg> uses gradients/filters/text/use and is not supported; rasterized.', elementDescription: describeElement$1(svg) });
+    return buildFallbackImageNode(svg, rect, visible, breakRules, 'unsupported SVG features', assetTasks, svg.getBoundingClientRect());
+}
+function buildFallbackImageNode(el, rect, visible, breakRules, reason, assetTasks, elRect) {
+    const node = {
+        id: nextId('fallback'),
+        type: 'image',
+        rect,
+        visible,
+        break: breakRules,
+        fallback: { reason },
+        source: { kind: 'data-url', value: '' },
+        fit: 'fill',
+        naturalWidth: rect.width,
+        naturalHeight: rect.height,
+        isFallbackRaster: true,
+    };
+    // Captured at the element's true on-screen size (not `rect`, which may
+    // later be shrunk by fit-to-width scaling) so the clone -- which still
+    // carries its original, unscaled inline styles -- isn't clipped inside
+    // its own raster. See docs/architecture.md "Hybrid rendering".
+    assetTasks.push({ kind: 'fallback', node, element: el, captureWidthPx: elRect.width, captureHeightPx: elRect.height });
+    return node;
+}
+function buildTableNode(table, rootRect, rect, visible, breakRules, options, assetTasks, warnings) {
+    const rowEls = Array.from(table.querySelectorAll('tr'));
+    const headerRowEls = new Set(Array.from(table.querySelectorAll('thead tr')));
+    const rows = rowEls.map((tr) => {
+        const trRect = relativeRect(tr.getBoundingClientRect(), rootRect);
+        const cellEls = Array.from(tr.children).filter((c) => c.tagName === 'TD' || c.tagName === 'TH');
+        const cells = cellEls.map((cellEl) => {
+            const cellRect = relativeRect(cellEl.getBoundingClientRect(), rootRect);
+            const cellStyle = getComputedStyle(cellEl);
+            const paint = readBoxPaint(cellStyle);
+            const content = walkChildren(cellEl, rootRect, options, assetTasks, warnings);
+            return {
+                id: nextId('cell'),
+                rect: cellRect,
+                isHeader: cellEl.tagName === 'TH',
+                paint,
+                content,
+            };
+        });
+        return {
+            id: nextId('row'),
+            rect: trRect,
+            isHeader: headerRowEls.has(tr),
+            cells,
+        };
+    });
+    const firstBodyRow = rows.find((r) => !r.isHeader) ?? rows[0];
+    const columns = (firstBodyRow?.cells ?? []).map((c) => ({ x: c.rect.x, width: c.rect.width }));
+    return {
+        id: nextId('table'),
+        type: 'table',
+        rect,
+        visible,
+        break: breakRules,
+        columns,
+        rows,
+        headerRowCount: rows.filter((r) => r.isHeader).length,
+        repeatHeader: true,
+    };
+}
+function describeElement$1(el) {
+    const id = el.id ? `#${el.id}` : '';
+    const cls = el.className && typeof el.className === 'string' ? `.${el.className.trim().split(/\s+/).join('.')}` : '';
+    return `<${el.tagName.toLowerCase()}${id}${cls}>`;
+}
+
+/**
+ * `padPx` reserves extra canvas space around the element's own border box
+ * for effects that visually bleed outside it (box-shadow, outline) --
+ * without this, capturing exactly the element's own rect would clip a
+ * shadow's blur/spread at the box edge. Callers should grow the node's
+ * placement rect by the same amount on every side and shift it up/left by
+ * `padPx` so the padded raster lands in the right place. See
+ * docs/css-support.md.
+ */
+async function rasterizeElement(el, widthPx, heightPx, scale, padPx = 0) {
+    if (widthPx <= 0 || heightPx <= 0) {
+        throw new Error('ngx-pdf-export: cannot rasterize an element with zero width/height.');
+    }
+    const totalWidthPx = widthPx + padPx * 2;
+    const totalHeightPx = heightPx + padPx * 2;
+    const clone = el.cloneNode(true);
+    inlineComputedStylesRecursive(el, clone);
+    copyCanvasBitmaps(el, clone);
+    resolveImageSources(clone);
+    clone.style.margin = '0';
+    clone.style.transform = 'none';
+    clone.style.position = 'static';
+    const svgNS = 'http://www.w3.org/2000/svg';
+    const xhtmlNS = 'http://www.w3.org/1999/xhtml';
+    const svg = document.createElementNS(svgNS, 'svg');
+    svg.setAttribute('xmlns', svgNS);
+    svg.setAttribute('width', String(totalWidthPx));
+    svg.setAttribute('height', String(totalHeightPx));
+    svg.setAttribute('viewBox', `0 0 ${totalWidthPx} ${totalHeightPx}`);
+    const foreignObject = document.createElementNS(svgNS, 'foreignObject');
+    foreignObject.setAttribute('width', '100%');
+    foreignObject.setAttribute('height', '100%');
+    const wrapper = document.createElementNS(xhtmlNS, 'div');
+    wrapper.setAttribute('xmlns', xhtmlNS);
+    wrapper.style.width = `${widthPx}px`;
+    wrapper.style.height = `${heightPx}px`;
+    wrapper.style.padding = `${padPx}px`;
+    wrapper.style.boxSizing = 'content-box';
+    wrapper.appendChild(clone);
+    foreignObject.appendChild(wrapper);
+    svg.appendChild(foreignObject);
+    const svgString = new XMLSerializer().serializeToString(svg);
+    const svgDataUrl = 'data:image/svg+xml;charset=utf-8,' + encodeURIComponent(svgString);
+    const img = await loadImage(svgDataUrl);
+    const canvas = document.createElement('canvas');
+    canvas.width = Math.ceil(totalWidthPx * scale);
+    canvas.height = Math.ceil(totalHeightPx * scale);
+    const ctx = canvas.getContext('2d');
+    if (!ctx) {
+        throw new Error('ngx-pdf-export: 2D canvas context unavailable.');
+    }
+    ctx.scale(scale, scale);
+    ctx.drawImage(img, 0, 0, totalWidthPx, totalHeightPx);
+    const dataUrl = canvas.toDataURL('image/png');
+    canvas.width = 0;
+    canvas.height = 0;
+    return { dataUrl, width: totalWidthPx, height: totalHeightPx };
+}
+function inlineComputedStylesRecursive(source, target) {
+    const computed = getComputedStyle(source);
+    const styleText = [];
+    for (let i = 0; i < computed.length; i++) {
+        const prop = computed.item(i);
+        styleText.push(`${prop}:${computed.getPropertyValue(prop)}`);
+    }
+    target.setAttribute('style', styleText.join(';'));
+    const sourceChildren = Array.from(source.children);
+    const targetChildren = Array.from(target.children);
+    for (let i = 0; i < sourceChildren.length; i++) {
+        if (targetChildren[i]) {
+            inlineComputedStylesRecursive(sourceChildren[i], targetChildren[i]);
+        }
+    }
+}
+function copyCanvasBitmaps(source, target) {
+    const sourceCanvases = Array.from(source.querySelectorAll('canvas'));
+    const targetCanvases = Array.from(target.querySelectorAll('canvas'));
+    for (let i = 0; i < sourceCanvases.length; i++) {
+        const src = sourceCanvases[i];
+        const dst = targetCanvases[i];
+        if (!dst)
+            continue;
+        dst.width = src.width;
+        dst.height = src.height;
+        const ctx = dst.getContext('2d');
+        try {
+            ctx?.drawImage(src, 0, 0);
+        }
+        catch {
+            // Cross-origin-tainted canvas: leave blank rather than throw.
+        }
+    }
+}
+function resolveImageSources(target) {
+    target.querySelectorAll('img').forEach((img) => {
+        const resolved = img.src; // IDL property is already absolute-resolved.
+        img.setAttribute('src', resolved);
+    });
+}
+function loadImage(src) {
+    return new Promise((resolve, reject) => {
+        const img = new Image();
+        img.onload = () => resolve(img);
+        img.onerror = () => reject(new Error('ngx-pdf-export: failed to rasterize fallback element.'));
+        img.src = src;
+    });
+}
+
+/** Extra capture margin (CSS px) around a rasterized fallback element, for box-shadow/outline bleed. See docs/css-support.md. */
+const FALLBACK_CAPTURE_PAD_PX = 24;
+/**
+ * Resolves every deferred asset (images, canvases, fallback rasterizations)
+ * to a data URL, mutating each task's node in place. Runs after layout so
+ * we only pay encode/fetch cost for assets that actually made it into the
+ * export. See docs/architecture.md "Performance" and docs/layout-engine.md
+ * §5.
+ */
+async function resolveAssets(tasks, scale, onWarning) {
+    await Promise.all(tasks.map(async (task) => {
+        try {
+            if (task.kind === 'img') {
+                task.node.source = { kind: 'data-url', value: await imageToDataUrl(task.element) };
+            }
+            else if (task.kind === 'canvas') {
+                task.node.source = { kind: 'data-url', value: task.element.toDataURL('image/png') };
+            }
+            else {
+                const result = await rasterizeElement(task.element, task.captureWidthPx, task.captureHeightPx, scale, FALLBACK_CAPTURE_PAD_PX);
+                task.node.source = { kind: 'data-url', value: result.dataUrl };
+                const padPt = pxToPt(FALLBACK_CAPTURE_PAD_PX);
+                task.node.rect = {
+                    x: task.node.rect.x - padPt,
+                    y: task.node.rect.y - padPt,
+                    width: task.node.rect.width + padPt * 2,
+                    height: task.node.rect.height + padPt * 2,
+                };
+                task.node.naturalWidth = result.width;
+                task.node.naturalHeight = result.height;
+            }
+        }
+        catch (err) {
+            task.node.visible = false;
+            onWarning({
+                message: task.kind === 'img' ? `Image could not be embedded (${err.message}). This is often a CORS restriction -- the image's server must send Access-Control-Allow-Origin, and the <img> needs crossorigin="anonymous".` : `Failed to render element: ${err.message}`,
+                elementDescription: describeElement(task.element),
+            });
+        }
+    }));
+}
+async function imageToDataUrl(img) {
+    const src = img.currentSrc || img.src;
+    if (src.startsWith('data:')) {
+        return src;
+    }
+    const response = await fetch(src, { mode: 'cors' });
+    if (!response.ok) {
+        throw new Error(`HTTP ${response.status}`);
+    }
+    const blob = await response.blob();
+    return await blobToDataUrl(blob);
+}
+function blobToDataUrl(blob) {
+    return new Promise((resolve, reject) => {
+        const reader = new FileReader();
+        reader.onload = () => resolve(reader.result);
+        reader.onerror = () => reject(new Error('failed to read image blob'));
+        reader.readAsDataURL(blob);
+    });
+}
+function describeElement(el) {
+    const id = el.id ? `#${el.id}` : '';
+    return `<${el.tagName.toLowerCase()}${id}>`;
+}
+
+/**
+ * Uniformly shrinks the whole captured flow (never enlarges) so its width
+ * fits the page's content width, the same "shrink to fit" behavior a
+ * browser's own print dialog applies to an over-wide page. Without this,
+ * any dashboard wider than the chosen page format (a very common case --
+ * most web layouts are wider than A4) would simply be clipped at the page
+ * edge. Every geometric quantity in the tree (rects, font sizes, border
+ * widths/radii, SVG coordinates) is scaled together so nothing distorts.
+ */
+function fitDocumentToWidth(doc, contentWidthPt) {
+    if (doc.flowWidthPt <= contentWidthPt || doc.flowWidthPt <= 0) {
+        return 1;
+    }
+    const scale = contentWidthPt / doc.flowWidthPt;
+    doc.flowWidthPt *= scale;
+    doc.flowHeightPt *= scale;
+    doc.children.forEach((child) => scaleNode(child, scale));
+    return scale;
+}
+function scaleRect(rect, scale) {
+    return { x: rect.x * scale, y: rect.y * scale, width: rect.width * scale, height: rect.height * scale };
+}
+function scaleNode(node, scale) {
+    node.rect = scaleRect(node.rect, scale);
+    switch (node.type) {
+        case 'text':
+            node.font = { ...node.font, sizePt: node.font.sizePt * scale };
+            node.letterSpacingPt *= scale;
+            node.baselineOffsetPt *= scale;
+            return;
+        case 'image':
+            node.naturalWidth *= scale;
+            node.naturalHeight *= scale;
+            return;
+        case 'svg':
+            node.commands = node.commands.map((cmd) => scaleSvgCommand(cmd, scale));
+            node.viewBox = scaleRect(node.viewBox, scale);
+            return;
+        case 'block':
+        case 'group':
+            scalePaintBorders(node, scale);
+            node.children.forEach((child) => scaleNode(child, scale));
+            return;
+        case 'table':
+            node.columns = node.columns.map((c) => ({ x: c.x * scale, width: c.width * scale }));
+            node.rows = node.rows.map((row) => scaleTableRow(row, scale));
+            return;
+    }
+}
+function scaleTableRow(row, scale) {
+    return {
+        ...row,
+        rect: scaleRect(row.rect, scale),
+        cells: row.cells.map((cell) => scaleTableCell(cell, scale)),
+    };
+}
+function scaleTableCell(cell, scale) {
+    scalePaintBorders(cell, scale);
+    return {
+        ...cell,
+        rect: scaleRect(cell.rect, scale),
+        content: cell.content.map((child) => {
+            scaleNode(child, scale);
+            return child;
+        }),
+    };
+}
+function scalePaintBorders(node, scale) {
+    const paint = node.paint;
+    if (paint.borders) {
+        for (const edge of Object.values(paint.borders)) {
+            edge.widthPt *= scale;
+        }
+    }
+    if (paint.borderRadius) {
+        for (const key of Object.keys(paint.borderRadius)) {
+            paint.borderRadius[key] *= scale;
+        }
+    }
+}
+function scaleSvgCommand(cmd, scale) {
+    const paint = { ...cmd.paint, strokeWidthPt: cmd.paint.strokeWidthPt * scale };
+    switch (cmd.op) {
+        case 'rect':
+            return { ...cmd, x: cmd.x * scale, y: cmd.y * scale, width: cmd.width * scale, height: cmd.height * scale, rx: cmd.rx * scale, ry: cmd.ry * scale, paint };
+        case 'ellipse':
+            return { ...cmd, cx: cmd.cx * scale, cy: cmd.cy * scale, rx: cmd.rx * scale, ry: cmd.ry * scale, paint };
+        case 'line':
+            return { ...cmd, x1: cmd.x1 * scale, y1: cmd.y1 * scale, x2: cmd.x2 * scale, y2: cmd.y2 * scale, paint };
+        case 'path':
+            return { ...cmd, d: scalePathData(cmd.d, scale, scale), paint };
+    }
+}
+
+const EPS = 0.01;
+function paginate(doc, contentBox) {
+    const CH = contentBox.contentHeightPt;
+    const pages = [];
+    const state = { shift: 0, hasPlaced: false, lastPageTouched: -1 };
+    const ensurePage = (idx) => {
+        while (pages.length <= idx)
+            pages.push({ primitives: [] });
+        return pages[idx];
+    };
+    const clipForPage = (clip, page) => (clip ? { ...clip, y: clip.y - page * CH } : undefined);
+    /** Places an atomic node (never split): moves it whole to the next page if it straddles a boundary or has a forced break-before. */
+    function pushAtomic(rect, breakBefore) {
+        let adjustedY = rect.y + state.shift;
+        let page = Math.floor(adjustedY / CH);
+        if (breakBefore === 'page' && state.hasPlaced && page === state.lastPageTouched) {
+            state.shift += (state.lastPageTouched + 1) * CH - adjustedY;
+            adjustedY = rect.y + state.shift;
+            page = Math.floor(adjustedY / CH);
+        }
+        const endPage = Math.floor((adjustedY + rect.height - EPS) / CH);
+        if (endPage !== page) {
+            state.shift += (page + 1) * CH - adjustedY;
+            adjustedY = rect.y + state.shift;
+            page = Math.floor(adjustedY / CH);
+        }
+        state.hasPlaced = true;
+        state.lastPageTouched = page;
+        ensurePage(page);
+        return { page, localY: adjustedY - page * CH };
+    }
+    function forceBreakAfter(bottomAdjusted) {
+        const bottomPage = Math.floor((bottomAdjusted - EPS) / CH);
+        state.shift += (bottomPage + 1) * CH - bottomAdjusted;
+        state.lastPageTouched = bottomPage + 1;
+    }
+    function placeContainerBackground(node, adjustedTop, adjustedBottom, clip) {
+        const hasPaint = !!(node.paint.backgroundColor || node.paint.borders || node.paint.backgroundImage);
+        if (!hasPaint)
+            return;
+        const firstPage = Math.max(0, Math.floor(adjustedTop / CH));
+        const lastPage = Math.floor((adjustedBottom - EPS) / CH);
+        for (let p = firstPage; p <= lastPage; p++) {
+            const pageTop = p * CH;
+            const pageBottom = pageTop + CH;
+            const vTop = Math.max(adjustedTop, pageTop);
+            const vBottom = Math.min(adjustedBottom, pageBottom);
+            if (vBottom <= vTop)
+                continue;
+            const rect = { x: node.rect.x, y: vTop - pageTop, width: node.rect.width, height: vBottom - vTop };
+            ensurePage(p).primitives.push({ kind: 'block', rect, node, clip: clipForPage(clip, p) });
+        }
+    }
+    function placeMedia(node, clip) {
+        if (node.rect.height <= CH) {
+            const { page, localY } = pushAtomic(node.rect, node.break.breakBefore);
+            ensurePage(page).primitives.push({ kind: node.type, rect: { ...node.rect, y: localY }, node, clip: clipForPage(clip, page) });
+            if (node.break.breakAfter === 'page')
+                forceBreakAfter(page * CH + localY + node.rect.height);
+            return;
+        }
+        // Oversized media: clip a slice onto every page it intersects (docs/pagination.md step 3).
+        const adjustedTop = node.rect.y + state.shift;
+        const adjustedBottom = adjustedTop + node.rect.height;
+        state.hasPlaced = true;
+        const firstPage = Math.max(0, Math.floor(adjustedTop / CH));
+        const lastPage = Math.floor((adjustedBottom - EPS) / CH);
+        for (let p = firstPage; p <= lastPage; p++) {
+            const pageTop = p * CH;
+            const pageBottom = pageTop + CH;
+            const vTop = Math.max(adjustedTop, pageTop);
+            const vBottom = Math.min(adjustedBottom, pageBottom);
+            if (vBottom <= vTop)
+                continue;
+            const rect = { x: node.rect.x, y: vTop - pageTop, width: node.rect.width, height: vBottom - vTop };
+            ensurePage(p).primitives.push({ kind: node.type, rect, node, clip: clipForPage(clip, p) });
+        }
+        state.lastPageTouched = lastPage;
+    }
+    function placeNode(node, clip) {
+        if (!node.visible)
+            return;
+        if (node.type === 'text') {
+            const { page, localY } = pushAtomic(node.rect, node.break.breakBefore);
+            ensurePage(page).primitives.push({ kind: 'text', rect: { ...node.rect, y: localY }, node, clip: clipForPage(clip, page) });
+            if (node.break.breakAfter === 'page')
+                forceBreakAfter(page * CH + localY + node.rect.height);
+            return;
+        }
+        if (node.type === 'image' || node.type === 'svg') {
+            placeMedia(node, clip);
+            return;
+        }
+        if (node.type === 'table') {
+            placeTable(node, clip);
+            return;
+        }
+        // block | group
+        const keepTogether = node.break.breakInside === 'avoid';
+        const fitsOnePage = node.rect.height <= CH;
+        if (keepTogether && fitsOnePage) {
+            const { page, localY } = pushAtomic(node.rect, node.break.breakBefore);
+            const adjustedTop = page * CH + localY;
+            const adjustedBottom = adjustedTop + node.rect.height;
+            placeContainerBackground(node, adjustedTop, adjustedBottom, clip);
+            const childClip = node.type === 'group' && node.clip ? { x: node.rect.x, y: adjustedTop, width: node.rect.width, height: node.rect.height } : clip;
+            for (const child of node.children)
+                placeNode(child, childClip);
+            if (node.break.breakAfter === 'page')
+                forceBreakAfter(adjustedBottom);
+            return;
+        }
+        // A keepTogether node taller than a full page can't actually be kept together;
+        // it falls through to normal per-child splitting below.
+        if (node.break.breakBefore === 'page') {
+            const adjustedY = node.rect.y + state.shift;
+            const page = Math.floor(adjustedY / CH);
+            if (state.hasPlaced && page === state.lastPageTouched) {
+                state.shift += (state.lastPageTouched + 1) * CH - adjustedY;
+            }
+        }
+        const shiftAtStart = state.shift;
+        const adjustedTop = node.rect.y + shiftAtStart;
+        const childClip = node.type === 'group' && node.clip ? { x: node.rect.x, y: adjustedTop, width: node.rect.width, height: node.rect.height } : clip;
+        for (const child of node.children)
+            placeNode(child, childClip);
+        const shiftAtEnd = state.shift;
+        const adjustedBottom = node.rect.y + node.rect.height + shiftAtEnd;
+        placeContainerBackground(node, adjustedTop, adjustedBottom, clip);
+        state.hasPlaced = true;
+        if (node.break.breakAfter === 'page') {
+            forceBreakAfter(adjustedBottom);
+        }
+        else {
+            state.lastPageTouched = Math.max(state.lastPageTouched, Math.floor((adjustedBottom - EPS) / CH));
+        }
+    }
+    function emitFixed(node, page, dy, clip) {
+        const rect = { ...node.rect, y: node.rect.y + dy };
+        if (node.type === 'text' || node.type === 'image' || node.type === 'svg') {
+            ensurePage(page).primitives.push({ kind: node.type, rect, node, clip: clipForPage(clip, page) });
+        }
+        else if (node.type === 'block' || node.type === 'group') {
+            if (node.paint.backgroundColor || node.paint.borders || node.paint.backgroundImage) {
+                ensurePage(page).primitives.push({ kind: 'block', rect, node, clip: clipForPage(clip, page) });
+            }
+            for (const child of node.children)
+                emitFixed(child, page, dy, clip);
+        }
+    }
+    function placeRowVisual(row, page, localY, clip) {
+        ensurePage(page);
+        const dy = localY - row.rect.y;
+        for (const cell of row.cells) {
+            if (cell.paint.backgroundColor || cell.paint.borders) {
+                const rect = { x: cell.rect.x, y: localY, width: cell.rect.width, height: row.rect.height };
+                const fakeCellBlock = { id: cell.id, type: 'block', rect, visible: true, break: { breakInside: 'avoid', breakBefore: 'auto', breakAfter: 'auto' }, paint: cell.paint, children: [] };
+                ensurePage(page).primitives.push({ kind: 'block', rect, node: fakeCellBlock, clip: clipForPage(clip, page) });
+            }
+            for (const child of cell.content)
+                emitFixed(child, page, dy, clip);
+        }
+    }
+    function placeTable(table, clip) {
+        const headerRows = table.rows.filter((r) => r.isHeader);
+        const bodyRows = table.rows.filter((r) => !r.isHeader);
+        let previousBodyPage = -1;
+        for (const hRow of headerRows) {
+            const { page, localY } = pushAtomic(hRow.rect, 'auto');
+            placeRowVisual(hRow, page, localY, clip);
+            previousBodyPage = page;
+        }
+        for (const row of bodyRows) {
+            const { page, localY } = pushAtomic(row.rect, 'auto');
+            let finalLocalY = localY;
+            if (table.repeatHeader && headerRows.length > 0 && page !== previousBodyPage) {
+                let offset = 0;
+                for (const hRow of headerRows) {
+                    placeRowVisual(hRow, page, offset, clip);
+                    offset += hRow.rect.height;
+                }
+                if (localY < offset) {
+                    state.shift += offset - localY;
+                    finalLocalY = offset;
+                    state.lastPageTouched = page;
+                }
+            }
+            placeRowVisual(row, page, finalLocalY, clip);
+            previousBodyPage = page;
+        }
+    }
+    for (const child of doc.children)
+        placeNode(child, undefined);
+    return { pages };
+}
+/**
+ * Flattens a small, self-contained node list (header/footer content) into
+ * primitives with no page-break logic -- used for content that is assumed
+ * to fit within its own reserved header/footer box. See docs/pagination.md
+ * "Headers / footers".
+ */
+function flattenLayoutNodes(nodes) {
+    const out = [];
+    const visit = (node) => {
+        if (!node.visible)
+            return;
+        if (node.type === 'text' || node.type === 'image' || node.type === 'svg') {
+            out.push({ kind: node.type, rect: node.rect, node });
+        }
+        else if (node.type === 'table') {
+            for (const row of node.rows) {
+                for (const cell of row.cells) {
+                    cell.content.forEach(visit);
+                }
+            }
+        }
+        else {
+            if (node.paint.backgroundColor || node.paint.borders || node.paint.backgroundImage) {
+                out.push({ kind: 'block', rect: node.rect, node });
+            }
+            for (const child of node.children)
+                visit(child);
+        }
+    };
+    for (const node of nodes)
+        visit(node);
+    return out;
+}
+
+function resolvePageGeometry(format, orientation, margin, extraTopPt, extraBottomPt) {
+    let widthPt;
+    let heightPt;
+    if (!format || format === 'A4') {
+        ({ widthPt, heightPt } = STANDARD_PAGE_SIZES_PT['A4']);
+    }
+    else if (typeof format === 'string') {
+        const preset = STANDARD_PAGE_SIZES_PT[format];
+        if (!preset)
+            throw new Error(`ngx-pdf-export: unknown page format "${format}".`);
+        ({ widthPt, heightPt } = preset);
+    }
+    else {
+        const unit = format.unit ?? 'mm';
+        const convert = unit === 'pt' ? (n) => n : unit === 'px' ? pxToPt : mmToPt;
+        widthPt = convert(format.width);
+        heightPt = convert(format.height);
+    }
+    if (orientation === 'landscape' && widthPt < heightPt) {
+        [widthPt, heightPt] = [heightPt, widthPt];
+    }
+    else if (orientation === 'portrait' && widthPt > heightPt) {
+        [widthPt, heightPt] = [heightPt, widthPt];
+    }
+    const resolvedMargin = resolveMargin(margin);
+    const contentWidthPt = widthPt - resolvedMargin.left - resolvedMargin.right;
+    const contentHeightPt = heightPt - resolvedMargin.top - resolvedMargin.bottom - extraTopPt - extraBottomPt;
+    if (contentWidthPt <= 0 || contentHeightPt <= 0) {
+        throw new Error('ngx-pdf-export: margins (and header/footer height) leave no room for content on the page.');
+    }
+    return { widthPt, heightPt, margin: resolvedMargin, contentWidthPt, contentHeightPt };
+}
+function resolveMargin(margin) {
+    if (margin === undefined) {
+        const mm10 = mmToPt(10);
+        return { top: mm10, right: mm10, bottom: mm10, left: mm10 };
+    }
+    if (typeof margin === 'number') {
+        const pt = mmToPt(margin);
+        return { top: pt, right: pt, bottom: pt, left: pt };
+    }
+    const mm10 = mmToPt(10);
+    return {
+        top: margin.top !== undefined ? mmToPt(margin.top) : mm10,
+        right: margin.right !== undefined ? mmToPt(margin.right) : mm10,
+        bottom: margin.bottom !== undefined ? mmToPt(margin.bottom) : mm10,
+        left: margin.left !== undefined ? mmToPt(margin.left) : mm10,
+    };
+}
+
+/**
+ * Resolves a text run's CSS-derived font to an embedded PDFFont, preferring
+ * a developer-registered custom font (full Unicode support, subset-embedded
+ * via fontkit) and falling back to the nearest Standard-14 font (WinAnsi
+ * only -- see docs/css-support.md "Unicode and non-Latin scripts").
+ */
+class FontResolver {
+    pdfDoc;
+    registry;
+    cache = new Map();
+    constructor(pdfDoc, registry) {
+        this.pdfDoc = pdfDoc;
+        this.registry = registry;
+    }
+    async resolve(font) {
+        const key = `${font.family}|${font.weight}|${font.style}`;
+        const cached = this.cache.get(key);
+        if (cached)
+            return cached;
+        const custom = this.registry.resolve(font.family, font.weight, font.style);
+        let embedded;
+        if (custom) {
+            embedded = await this.pdfDoc.embedFont(custom.bytes, { subset: true });
+        }
+        else {
+            embedded = await this.pdfDoc.embedFont(pickStandardFont(font));
+        }
+        this.cache.set(key, embedded);
+        return embedded;
+    }
+}
+function pickStandardFont(font) {
+    const family = font.family.toLowerCase();
+    const bold = font.weight >= 600;
+    const italic = font.style === 'italic';
+    if (/mono|courier|consolas|menlo/.test(family)) {
+        if (bold && italic)
+            return StandardFonts.CourierBoldOblique;
+        if (bold)
+            return StandardFonts.CourierBold;
+        if (italic)
+            return StandardFonts.CourierOblique;
+        return StandardFonts.Courier;
+    }
+    if (/times|serif|georgia|garamond/.test(family)) {
+        if (bold && italic)
+            return StandardFonts.TimesRomanBoldItalic;
+        if (bold)
+            return StandardFonts.TimesRomanBold;
+        if (italic)
+            return StandardFonts.TimesRomanItalic;
+        return StandardFonts.TimesRoman;
+    }
+    if (bold && italic)
+        return StandardFonts.HelveticaBoldOblique;
+    if (bold)
+        return StandardFonts.HelveticaBold;
+    if (italic)
+        return StandardFonts.HelveticaOblique;
+    return StandardFonts.Helvetica;
+}
+
+async function renderPdf(pages, fontRegistry, options, headerFooter) {
+    const pdfDoc = await PDFDocument.create();
+    pdfDoc.registerFontkit(fontkit);
+    const fontResolver = new FontResolver(pdfDoc, fontRegistry);
+    const imageCache = new Map();
+    const warnedGlyphs = new Set();
+    for (let i = 0; i < pages.length; i++) {
+        const page = pages[i];
+        const pdfPage = pdfDoc.addPage([options.geometry.widthPt, options.geometry.heightPt]);
+        for (const primitive of page.primitives) {
+            await drawPrimitive(pdfDoc, pdfPage, primitive, options, fontResolver, imageCache, warnedGlyphs);
+        }
+        const headerPrimitives = headerFooter?.headerPrimitivesPerPage?.[i];
+        if (headerPrimitives?.length && headerFooter?.headerGeometry) {
+            const headerOptions = { ...options, geometry: headerFooter.headerGeometry };
+            for (const primitive of headerPrimitives) {
+                await drawPrimitive(pdfDoc, pdfPage, primitive, headerOptions, fontResolver, imageCache, warnedGlyphs);
+            }
+        }
+        const footerPrimitives = headerFooter?.footerPrimitivesPerPage?.[i];
+        if (footerPrimitives?.length && headerFooter?.footerGeometry) {
+            const footerOptions = { ...options, geometry: headerFooter.footerGeometry };
+            for (const primitive of footerPrimitives) {
+                await drawPrimitive(pdfDoc, pdfPage, primitive, footerOptions, fontResolver, imageCache, warnedGlyphs);
+            }
+        }
+        if (options.debug) {
+            pdfPage.drawRectangle({
+                x: 0,
+                y: 0,
+                width: options.geometry.widthPt,
+                height: options.geometry.heightPt,
+                borderColor: rgb(1, 0, 0),
+                borderWidth: 1,
+                borderDashArray: [4, 4],
+            });
+        }
+    }
+    return pdfDoc.save();
+}
+function rgbFrom(c) {
+    return rgb(c.r / 255, c.g / 255, c.b / 255);
+}
+function toPdfSpace(rect, geometry) {
+    const x = geometry.marginLeftPt + rect.x;
+    const topY = geometry.marginTopPt + rect.y;
+    const bottomYPdf = geometry.heightPt - (topY + rect.height);
+    const topYPdf = geometry.heightPt - topY;
+    return { x, topY: topYPdf, bottomY: bottomYPdf, width: rect.width, height: rect.height };
+}
+async function drawPrimitive(pdfDoc, pdfPage, primitive, options, fontResolver, imageCache, warnedGlyphs) {
+    const clipRect = primitive.clip ? toPdfSpace(primitive.clip, options.geometry) : undefined;
+    if (clipRect) {
+        pushClip(pdfPage, clipRect);
+    }
+    try {
+        switch (primitive.kind) {
+            case 'block':
+                drawBox(pdfPage, primitive.node, primitive.rect, options);
+                if (options.debug && primitive.node.fallback) {
+                    drawDebugOutline(pdfPage, primitive.rect, options.geometry);
+                }
+                break;
+            case 'text':
+                await drawText(pdfPage, primitive.node, primitive.rect, options, fontResolver, warnedGlyphs);
+                break;
+            case 'image':
+                await drawImage(pdfDoc, pdfPage, primitive.node, primitive.rect, options, imageCache);
+                if (options.debug && primitive.node.isFallbackRaster) {
+                    drawDebugOutline(pdfPage, primitive.rect, options.geometry);
+                }
+                break;
+            case 'svg':
+                drawSvg(pdfPage, primitive.node, primitive.rect, options.geometry);
+                break;
+        }
+    }
+    finally {
+        if (clipRect) {
+            popClip(pdfPage);
+        }
+    }
+}
+function pushClip(page, r) {
+    page.pushOperators(pushGraphicsState(), moveTo(r.x, r.bottomY), lineTo(r.x + r.width, r.bottomY), lineTo(r.x + r.width, r.bottomY + r.height), lineTo(r.x, r.bottomY + r.height), closePath(), clip(), endPath());
+}
+function popClip(page) {
+    page.pushOperators(popGraphicsState());
+}
+function drawDebugOutline(page, rect, geometry) {
+    const p = toPdfSpace(rect, geometry);
+    page.drawRectangle({ x: p.x, y: p.bottomY, width: p.width, height: p.height, borderColor: rgb(1, 0, 0), borderWidth: 1, borderDashArray: [2, 2] });
+}
+// ---- box (background/border/border-radius) ----
+function drawBox(page, node, rect, options) {
+    const p = toPdfSpace(rect, options.geometry);
+    const paint = node.paint;
+    const radius = paint.borderRadius;
+    const hasRadius = !!radius && (radius.topLeft || radius.topRight || radius.bottomRight || radius.bottomLeft);
+    if (hasRadius) {
+        const d = roundedRectPath(p.width, p.height, radius);
+        const drawOpts = { x: p.x, y: p.topY };
+        if (paint.backgroundColor && paint.backgroundColor.a > 0) {
+            drawOpts.color = rgbFrom(paint.backgroundColor);
+            drawOpts.opacity = paint.backgroundColor.a * paint.opacity;
+        }
+        const edge = firstPaintedEdge(paint.borders);
+        if (edge) {
+            drawOpts.borderColor = rgbFrom(edge.color);
+            drawOpts.borderWidth = edge.widthPt;
+            drawOpts.borderOpacity = edge.color.a * paint.opacity;
+            applyDash(drawOpts, edge);
+        }
+        if (drawOpts.color || drawOpts.borderColor) {
+            page.drawSvgPath(d, drawOpts);
+        }
+        return;
+    }
+    if (paint.backgroundColor && paint.backgroundColor.a > 0) {
+        page.drawRectangle({ x: p.x, y: p.bottomY, width: p.width, height: p.height, color: rgbFrom(paint.backgroundColor), opacity: paint.backgroundColor.a * paint.opacity });
+    }
+    if (paint.borders) {
+        drawEdgeLine(page, paint.borders.top, p.x, p.topY, p.x + p.width, p.topY, paint.opacity);
+        drawEdgeLine(page, paint.borders.bottom, p.x, p.bottomY, p.x + p.width, p.bottomY, paint.opacity);
+        drawEdgeLine(page, paint.borders.left, p.x, p.bottomY, p.x, p.topY, paint.opacity);
+        drawEdgeLine(page, paint.borders.right, p.x + p.width, p.bottomY, p.x + p.width, p.topY, paint.opacity);
+    }
+}
+function firstPaintedEdge(borders) {
+    if (!borders)
+        return undefined;
+    return [borders.top, borders.right, borders.bottom, borders.left].find((e) => e.style !== 'none' && e.widthPt > 0);
+}
+function applyDash(drawOpts, edge) {
+    if (edge.style === 'dashed') {
+        drawOpts.borderDashArray = [edge.widthPt * 2.5, edge.widthPt * 2];
+    }
+    else if (edge.style === 'dotted') {
+        drawOpts.borderDashArray = [edge.widthPt * 0.6, edge.widthPt * 1.4];
+    }
+}
+function drawEdgeLine(page, edge, x1, y1, x2, y2, groupOpacity) {
+    if (edge.style === 'none' || edge.widthPt <= 0)
+        return;
+    const dashArray = edge.style === 'dashed' ? [edge.widthPt * 2.5, edge.widthPt * 2] : edge.style === 'dotted' ? [edge.widthPt * 0.6, edge.widthPt * 1.4] : undefined;
+    page.drawLine({ start: { x: x1, y: y1 }, end: { x: x2, y: y2 }, thickness: edge.widthPt, color: rgbFrom(edge.color), opacity: edge.color.a * groupOpacity, dashArray });
+}
+function roundedRectPath(w, h, r) {
+    const tl = Math.min(r.topLeft, w / 2, h / 2);
+    const tr = Math.min(r.topRight, w / 2, h / 2);
+    const br = Math.min(r.bottomRight, w / 2, h / 2);
+    const bl = Math.min(r.bottomLeft, w / 2, h / 2);
+    return [
+        `M ${tl} 0`,
+        `L ${w - tr} 0`,
+        `Q ${w} 0 ${w} ${tr}`,
+        `L ${w} ${h - br}`,
+        `Q ${w} ${h} ${w - br} ${h}`,
+        `L ${bl} ${h}`,
+        `Q 0 ${h} 0 ${h - bl}`,
+        `L 0 ${tl}`,
+        `Q 0 0 ${tl} 0`,
+        'Z',
+    ].join(' ');
+}
+// ---- text ----
+async function drawText(page, node, rect, options, fontResolver, warnedGlyphs) {
+    const font = await fontResolver.resolve(node.font);
+    const p = toPdfSpace(rect, options.geometry);
+    const size = node.font.sizePt;
+    const baselineY = options.geometry.heightPt - (options.geometry.marginTopPt + rect.y + node.baselineOffsetPt);
+    const color = rgbFrom(node.color);
+    const opacity = node.color.a;
+    const textWidth = measureText(font, node.text, size, node.letterSpacingPt);
+    let x = p.x;
+    if (node.align === 'center')
+        x = p.x + Math.max(0, (rect.width - textWidth) / 2);
+    else if (node.align === 'right')
+        x = p.x + Math.max(0, rect.width - textWidth);
+    drawGlyphsSafely(page, font, node.text, x, baselineY, size, color, opacity, node.letterSpacingPt, warnedGlyphs, (msg) => options.onWarning({ message: msg, elementDescription: node.text.slice(0, 40) }));
+    if (node.decoration.underline) {
+        page.drawLine({ start: { x, y: baselineY - size * 0.08 }, end: { x: x + textWidth, y: baselineY - size * 0.08 }, thickness: Math.max(0.5, size * 0.05), color, opacity });
+    }
+    if (node.decoration.lineThrough) {
+        page.drawLine({ start: { x, y: baselineY + size * 0.3 }, end: { x: x + textWidth, y: baselineY + size * 0.3 }, thickness: Math.max(0.5, size * 0.05), color, opacity });
+    }
+}
+function measureText(font, text, size, letterSpacingPt) {
+    let w = 0;
+    for (const ch of text)
+        w += safeWidth(font, ch, size);
+    return w + letterSpacingPt * Math.max(0, [...text].length - 1);
+}
+function safeWidth(font, ch, size) {
+    try {
+        return font.widthOfTextAtSize(ch, size);
+    }
+    catch {
+        return size * 0.5;
+    }
+}
+function drawGlyphsSafely(page, font, text, x0, y, size, color, opacity, letterSpacingPt, warnedGlyphs, onWarning) {
+    if (letterSpacingPt === 0 && canEncodeAll(font, text)) {
+        page.drawText(text, { x: x0, y, size, font, color, opacity });
+        return;
+    }
+    let x = x0;
+    for (const ch of text) {
+        if (canEncodeAll(font, ch)) {
+            page.drawText(ch, { x, y, size, font, color, opacity });
+        }
+        else if (!warnedGlyphs.has(ch)) {
+            warnedGlyphs.add(ch);
+            onWarning(`Character "${ch}" has no glyph in the resolved font and was skipped. Register a Unicode-capable font via registerFont() for this text.`);
+        }
+        x += safeWidth(font, ch, size) + letterSpacingPt;
+    }
+}
+function canEncodeAll(font, text) {
+    try {
+        font.widthOfTextAtSize(text, 10);
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+// ---- images ----
+async function drawImage(pdfDoc, page, node, rect, options, cache) {
+    if (!node.source.value)
+        return;
+    let embedded = cache.get(node.source.value);
+    if (!embedded) {
+        const decoded = decodeDataUrl(node.source.value);
+        if (!decoded)
+            return;
+        embedded = decoded.isPng ? await pdfDoc.embedPng(decoded.bytes) : await pdfDoc.embedJpg(decoded.bytes);
+        cache.set(node.source.value, embedded);
+    }
+    const box = toPdfSpace(rect, options.geometry);
+    const natW = node.naturalWidth || embedded.width;
+    const natH = node.naturalHeight || embedded.height;
+    let drawW = box.width;
+    let drawH = box.height;
+    let drawX = box.x;
+    let drawTopY = options.geometry.marginTopPt + rect.y;
+    if ((node.fit === 'contain' || node.fit === 'cover') && natW > 0 && natH > 0) {
+        const scale = node.fit === 'contain' ? Math.min(box.width / natW, box.height / natH) : Math.max(box.width / natW, box.height / natH);
+        drawW = natW * scale;
+        drawH = natH * scale;
+        drawX = box.x + (box.width - drawW) / 2;
+        drawTopY = options.geometry.marginTopPt + rect.y + (box.height - drawH) / 2;
+    }
+    else if (node.fit === 'none' && natW > 0 && natH > 0) {
+        drawW = natW;
+        drawH = natH;
+    }
+    const drawBottomYPdf = options.geometry.heightPt - (drawTopY + drawH);
+    const needsClip = drawW > box.width + 0.5 || drawH > box.height + 0.5;
+    if (needsClip) {
+        pushClip(page, box);
+    }
+    page.drawImage(embedded, { x: drawX, y: drawBottomYPdf, width: drawW, height: drawH });
+    if (needsClip) {
+        popClip(page);
+    }
+}
+function decodeDataUrl(dataUrl) {
+    const match = /^data:image\/(png|jpe?g);base64,(.*)$/i.exec(dataUrl);
+    if (!match)
+        return null;
+    const isPng = match[1].toLowerCase() === 'png';
+    const binary = atob(match[2]);
+    const bytes = new Uint8Array(binary.length);
+    for (let i = 0; i < binary.length; i++)
+        bytes[i] = binary.charCodeAt(i);
+    return { bytes, isPng };
+}
+// ---- svg ----
+function drawSvg(page, node, rect, geometry) {
+    const p = toPdfSpace(rect, geometry);
+    for (const cmd of node.commands) {
+        drawSvgCommand(page, cmd, p.x, p.topY);
+    }
+}
+function drawSvgCommand(page, cmd, originX, originTopY) {
+    const paint = cmd.paint;
+    const drawOpts = {};
+    if (paint.fill) {
+        drawOpts.color = rgbFrom(paint.fill);
+        drawOpts.opacity = paint.fill.a * paint.opacity;
+    }
+    if (paint.stroke && paint.strokeWidthPt > 0) {
+        drawOpts.borderColor = rgbFrom(paint.stroke);
+        drawOpts.borderWidth = paint.strokeWidthPt;
+        drawOpts.borderOpacity = paint.stroke.a * paint.opacity;
+    }
+    if (!drawOpts.color && !drawOpts.borderColor)
+        return;
+    switch (cmd.op) {
+        case 'rect': {
+            const hasRadius = cmd.rx > 0 || cmd.ry > 0;
+            if (hasRadius) {
+                const d = roundedRectPath(cmd.width, cmd.height, { topLeft: cmd.rx, topRight: cmd.rx, bottomRight: cmd.rx, bottomLeft: cmd.rx });
+                page.drawSvgPath(d, { ...drawOpts, x: originX + cmd.x, y: originTopY - cmd.y });
+            }
+            else {
+                page.drawRectangle({ x: originX + cmd.x, y: originTopY - cmd.y - cmd.height, width: cmd.width, height: cmd.height, color: drawOpts.color, opacity: drawOpts.opacity, borderColor: drawOpts.borderColor, borderWidth: drawOpts.borderWidth, borderOpacity: drawOpts.borderOpacity });
+            }
+            break;
+        }
+        case 'ellipse':
+            page.drawEllipse({ x: originX + cmd.cx, y: originTopY - cmd.cy, xScale: cmd.rx, yScale: cmd.ry, color: drawOpts.color, opacity: drawOpts.opacity, borderColor: drawOpts.borderColor, borderWidth: drawOpts.borderWidth, borderOpacity: drawOpts.borderOpacity });
+            break;
+        case 'line':
+            if (drawOpts.borderColor) {
+                page.drawLine({ start: { x: originX + cmd.x1, y: originTopY - cmd.y1 }, end: { x: originX + cmd.x2, y: originTopY - cmd.y2 }, thickness: drawOpts.borderWidth, color: drawOpts.borderColor, opacity: drawOpts.borderOpacity });
+            }
+            break;
+        case 'path':
+            page.drawSvgPath(cmd.d, { ...drawOpts, x: originX, y: originTopY });
+            break;
+    }
+}
+
+/**
+ * Builds the layout nodes for one page's header or footer callback result.
+ * A returned string becomes a single default-styled text run; a returned
+ * HTMLElement is run through the same DOM-inspection path as the body
+ * (briefly attached off-screen so getBoundingClientRect/getComputedStyle
+ * are meaningful), per docs/pagination.md "Headers / footers".
+ */
+async function buildHeaderFooterNodes(result, boxWidthPt, boxHeightPt, scale, onWarning) {
+    if (typeof result === 'string') {
+        if (!result.trim())
+            return [];
+        const sizePt = 10;
+        const node = {
+            id: 'header-footer-text',
+            type: 'text',
+            rect: { x: 0, y: 0, width: boxWidthPt, height: boxHeightPt },
+            visible: true,
+            break: { breakInside: 'avoid', breakBefore: 'auto', breakAfter: 'auto' },
+            text: result,
+            font: { family: 'Helvetica', weight: 400, style: 'normal', sizePt },
+            color: { r: 80, g: 80, b: 80, a: 1 },
+            letterSpacingPt: 0,
+            align: 'left',
+            decoration: { underline: false, lineThrough: false },
+            baselineOffsetPt: boxHeightPt / 2 + sizePt * 0.35,
+        };
+        return [node];
+    }
+    const host = document.createElement('div');
+    host.style.position = 'fixed';
+    host.style.top = '0';
+    host.style.left = '-99999px';
+    host.style.width = `${boxWidthPt / 0.75}px`;
+    host.appendChild(result);
+    document.body.appendChild(host);
+    try {
+        const { document: doc, assetTasks, warnings } = inspectElement(result, { keepTogetherSelectors: [] });
+        warnings.forEach(onWarning);
+        await resolveAssets(assetTasks, scale, onWarning);
+        return doc.children;
+    }
+    finally {
+        document.body.removeChild(host);
+    }
+}
+function pageContext(pageNumber, pageCount) {
+    return { pageNumber, pageCount };
+}
+
+async function runExport(root, options, fontRegistry) {
+    validateTarget(root);
+    const warnings = [];
+    const onWarning = (w) => {
+        warnings.push(w);
+        options.onWarning?.(w);
+        // eslint-disable-next-line no-console
+        console.warn(`[ngx-pdf-export] ${w.message} (${w.elementDescription})`);
+    };
+    const scale = options.scale ?? 2;
+    const headerHeightPt = options.header ? options.headerHeight ?? 24 : 0;
+    const footerHeightPt = options.footer ? options.footerHeight ?? 24 : 0;
+    const geometry = resolvePageGeometry(options.format, options.orientation, options.margin, headerHeightPt, footerHeightPt);
+    const { document: doc, assetTasks, warnings: inspectWarnings } = inspectElement(root, {
+        keepTogetherSelectors: options.keepTogether ?? [],
+    });
+    inspectWarnings.forEach(onWarning);
+    const fitScale = fitDocumentToWidth(doc, geometry.contentWidthPt);
+    if (fitScale < 1) {
+        onWarning({ message: `Content is wider than the page (by ${Math.round((1 / fitScale - 1) * 100)}%) and was scaled down to fit.`, elementDescription: `<${root.tagName.toLowerCase()}>` });
+    }
+    await resolveAssets(assetTasks, scale, onWarning);
+    if (options.repeatTableHeaders === false) {
+        disableTableHeaderRepeat(doc.children);
+    }
+    const paginated = paginate(doc, { contentHeightPt: geometry.contentHeightPt });
+    const pageCount = paginated.pages.length || 1;
+    const bodyGeometry = {
+        widthPt: geometry.widthPt,
+        heightPt: geometry.heightPt,
+        marginTopPt: geometry.margin.top + headerHeightPt,
+        marginLeftPt: geometry.margin.left,
+    };
+    let headerFooter;
+    if (options.header || options.footer) {
+        const headerGeometry = { widthPt: geometry.widthPt, heightPt: geometry.heightPt, marginTopPt: geometry.margin.top, marginLeftPt: geometry.margin.left };
+        const footerGeometry = { widthPt: geometry.widthPt, heightPt: geometry.heightPt, marginTopPt: geometry.heightPt - geometry.margin.bottom - footerHeightPt, marginLeftPt: geometry.margin.left };
+        const headerPrimitivesPerPage = options.header
+            ? await Promise.all(Array.from({ length: pageCount }, (_, i) => i).map(async (i) => {
+                const result = options.header(pageContext(i + 1, pageCount));
+                const nodes = await buildHeaderFooterNodes(result, geometry.contentWidthPt, headerHeightPt, scale, onWarning);
+                return flattenLayoutNodes(nodes);
+            }))
+            : undefined;
+        const footerPrimitivesPerPage = options.footer
+            ? await Promise.all(Array.from({ length: pageCount }, (_, i) => i).map(async (i) => {
+                const result = options.footer(pageContext(i + 1, pageCount));
+                const nodes = await buildHeaderFooterNodes(result, geometry.contentWidthPt, footerHeightPt, scale, onWarning);
+                return flattenLayoutNodes(nodes);
+            }))
+            : undefined;
+        headerFooter = { headerPrimitivesPerPage, footerPrimitivesPerPage, headerGeometry, footerGeometry };
+    }
+    const bytes = await renderPdf(paginated.pages, fontRegistry, { geometry: bodyGeometry, debug: !!options.debug, onWarning }, headerFooter);
+    return new Blob([bytes], { type: 'application/pdf' });
+}
+function validateTarget(root) {
+    if (!root) {
+        throw new Error('ngx-pdf-export: export target not found.');
+    }
+    if (!root.isConnected) {
+        throw new Error('ngx-pdf-export: export target is not attached to the document. The element must be rendered (not display:none, not in a detached view) at export time.');
+    }
+    const rect = root.getBoundingClientRect();
+    if (rect.width <= 0 || rect.height <= 0) {
+        throw new Error('ngx-pdf-export: export target has zero width or height.');
+    }
+}
+function disableTableHeaderRepeat(nodes) {
+    for (const node of nodes) {
+        if (node.type === 'table') {
+            node.repeatHeader = false;
+        }
+        else if (node.type === 'block' || node.type === 'group') {
+            disableTableHeaderRepeat(node.children);
+        }
+    }
+}
+
+/**
+ * Holds developer-registered custom fonts (see docs/api-design.md "Font
+ * registration"). Resolution is family match -> nearest registered weight
+ * for that family+style, falling back to the opposite style if no exact
+ * style match exists. Standard-14 fallback happens in render/fonts.ts,
+ * outside this class, since it needs a live PDFDocument to embed against.
+ */
+class FontRegistry {
+    sources = [];
+    async register(font) {
+        const bytes = typeof font.src === 'string' ? await fetchBytes(font.src) : font.src;
+        this.sources.push({
+            family: font.family,
+            weight: font.weight ?? 400,
+            style: font.style ?? 'normal',
+            bytes,
+        });
+    }
+    resolve(family, weight, style) {
+        const candidates = this.sources.filter((s) => s.family.toLowerCase() === family.toLowerCase());
+        if (candidates.length === 0) {
+            return undefined;
+        }
+        const styleMatches = candidates.filter((c) => c.style === style);
+        const pool = styleMatches.length > 0 ? styleMatches : candidates;
+        return pool.reduce((best, c) => (Math.abs(c.weight - weight) < Math.abs(best.weight - weight) ? c : best));
+    }
+    hasAnyFontFor(family) {
+        return this.sources.some((s) => s.family.toLowerCase() === family.toLowerCase());
+    }
+}
+async function fetchBytes(url) {
+    const response = await fetch(url);
+    if (!response.ok) {
+        throw new Error(`ngx-pdf-export: failed to fetch font "${url}" (HTTP ${response.status}).`);
+    }
+    return response.arrayBuffer();
+}
+
+/**
+ * Accepts either `(target, options)` or a single `{ element, ...options }`
+ * object -- see docs/api-design.md.
+ */
+function normalizeArgs(target, options) {
+    if (isOptionsWithElement(target)) {
+        const { element, ...rest } = target;
+        return { element, opts: rest };
+    }
+    return { element: target, opts: options ?? {} };
+}
+function isOptionsWithElement(value) {
+    return typeof value === 'object' && value !== null && !(value instanceof ElementRef) && !(value instanceof HTMLElement) && 'element' in value;
+}
+function resolveElement(target) {
+    if (typeof target === 'string') {
+        const found = document.querySelector(target);
+        if (!found) {
+            throw new Error(`ngx-pdf-export: no element matches selector "${target}".`);
+        }
+        return found;
+    }
+    if (target instanceof ElementRef) {
+        return target.nativeElement;
+    }
+    return target;
+}
+
+/**
+ * The library's public entry point. See docs/api-design.md "Public surface".
+ * `export`/`download`/`toBlob` all accept either `(target, options)` or a
+ * single `{ element, ...options }` object.
+ */
+class PdfExportService {
+    fontRegistry = new FontRegistry();
+    /** Registers a custom TTF/OTF font for embedding -- see docs/api-design.md "Font registration". */
+    async registerFont(font) {
+        await this.fontRegistry.register(font);
+    }
+    /** Builds the PDF and returns it as a Blob, without triggering a download. */
+    async toBlob(target, options) {
+        const { element, opts } = normalizeArgs(target, options);
+        const root = resolveElement(element);
+        return runExport(root, opts, this.fontRegistry);
+    }
+    /** Builds the PDF and triggers a browser download. Alias for `download()` with the brief's example call shape. */
+    async export(target, options) {
+        const { element, opts } = normalizeArgs(target, options);
+        const blob = await this.toBlob(element, opts);
+        triggerDownload(blob, opts.filename ?? 'document.pdf');
+    }
+    /** Builds the PDF and triggers a browser download with an explicit filename. */
+    async download(target, filename, options) {
+        const { element, opts } = normalizeArgs(target, options);
+        const finalFilename = filename ?? opts.filename ?? 'document.pdf';
+        const blob = await this.toBlob(element, opts);
+        triggerDownload(blob, finalFilename);
+    }
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "22.1.6", ngImport: i0, type: PdfExportService, deps: [], target: i0.ɵɵFactoryTarget.Injectable });
+    static ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "22.1.6", ngImport: i0, type: PdfExportService, providedIn: 'root' });
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "22.1.6", ngImport: i0, type: PdfExportService, decorators: [{
+            type: Injectable,
+            args: [{ providedIn: 'root' }]
+        }] });
+function triggerDownload(blob, filename) {
+    const url = URL.createObjectURL(blob);
+    const link = document.createElement('a');
+    link.href = url;
+    link.download = filename;
+    link.style.display = 'none';
+    document.body.appendChild(link);
+    link.click();
+    document.body.removeChild(link);
+    setTimeout(() => URL.revokeObjectURL(url), 1000);
+}
+
+/**
+ * Thin wrapper around PdfExportService for template-driven use:
+ *
+ * ```html
+ * <div id="dashboard" pdfExport pdfFileName="dashboard.pdf" #dash="pdfExport">
+ *   ...
+ * </div>
+ * <button (click)="dash.export()">Export</button>
+ * ```
+ *
+ * By default this does not attach its own click handler -- the host element
+ * shown in the brief's example is the content being exported, not
+ * necessarily a button. Set `pdfTrigger="click"` to export when the host
+ * element itself is clicked.
+ */
+class PdfExportDirective {
+    elementRef;
+    pdf;
+    pdfFileName;
+    pdfOptions;
+    pdfTrigger = 'none';
+    constructor(elementRef, pdf) {
+        this.elementRef = elementRef;
+        this.pdf = pdf;
+    }
+    onHostClick() {
+        if (this.pdfTrigger === 'click') {
+            void this.export();
+        }
+    }
+    async export() {
+        await this.pdf.download(this.elementRef.nativeElement, this.pdfFileName, this.pdfOptions);
+    }
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "22.1.6", ngImport: i0, type: PdfExportDirective, deps: [{ token: i0.ElementRef }, { token: PdfExportService }], target: i0.ɵɵFactoryTarget.Directive });
+    static ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "14.0.0", version: "22.1.6", type: PdfExportDirective, isStandalone: true, selector: "[pdfExport]", inputs: { pdfFileName: "pdfFileName", pdfOptions: "pdfOptions", pdfTrigger: "pdfTrigger" }, host: { listeners: { "click": "onHostClick()" } }, exportAs: ["pdfExport"], ngImport: i0 });
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "22.1.6", ngImport: i0, type: PdfExportDirective, decorators: [{
+            type: Directive,
+            args: [{
+                    selector: '[pdfExport]',
+                    exportAs: 'pdfExport',
+                }]
+        }], ctorParameters: () => [{ type: i0.ElementRef }, { type: PdfExportService }], propDecorators: { pdfFileName: [{
+                type: Input
+            }], pdfOptions: [{
+                type: Input
+            }], pdfTrigger: [{
+                type: Input
+            }], onHostClick: [{
+                type: HostListener,
+                args: ['click']
+            }] } });
+
+/*
+ * Public API surface of ngx-pdf-export.
+ * Keep this small and curated -- see docs/api-design.md "Public surface".
+ */
+
+/**
+ * Generated bundle index. Do not edit.
+ */
+
+export { PdfExportDirective, PdfExportService };
+//# sourceMappingURL=ngx-pdf-export.mjs.map