pagyra-js 0.0.20 → 0.0.21

package/dist/src/html/dom-converter.js

@@ -1,417 +1 @@
-// src/html/dom-converter.ts
-import {} from "./css/parse-css.js";
-import { LayoutNode } from "../dom/node.js";
-import { ComputedStyle } from "../css/style.js";
-import { cloneLineHeight } from "../css/line-height.js";
-import { computeStyleForElement } from "../css/compute-style.js";
-import { convertImageElement, resolveImageSource, canLoadHttpResource } from "./image-converter.js";
-import { Display, WhiteSpace } from "../css/enums.js";
-import { parseSvg } from "../svg/parser.js";
-import { ImageService } from "../image/image-service.js";
-import { log } from "../logging/debug.js";
-import { decodeBase64ToUint8Array } from "../utils/base64.js";
-import { defaultFormRegistry, extractFormControlData } from "../dom/form-registry.js";
-function findMeaningfulSibling(start, direction) {
-    let current = start;
-    const getNext = direction === "previous"
-        ? (node) => node.previousSibling
-        : (node) => node.nextSibling;
-    while (current) {
-        if (current.nodeType === current.TEXT_NODE) {
-            const content = current.textContent ?? "";
-            if (content.replace(/\s+/g, "").length > 0) {
-                return current;
-            }
-        }
-        else if (current.nodeType === current.ELEMENT_NODE) {
-            const tagName = current.tagName.toLowerCase();
-            if (!["script", "style", "meta", "link"].includes(tagName)) {
-                return current;
-            }
-        }
-        current = getNext(current);
-    }
-    return null;
-}
-function hasMeaningfulPreviousSibling(node) {
-    return findMeaningfulSibling(node.previousSibling, "previous") !== null;
-}
-function hasMeaningfulNextSibling(node) {
-    return findMeaningfulSibling(node.nextSibling, "next") !== null;
-}
-function isInlineDisplay(display) {
-    return (display === Display.Inline ||
-        display === Display.InlineBlock ||
-        display === Display.InlineFlex ||
-        display === Display.InlineGrid ||
-        display === Display.InlineTable);
-}
-function shouldPreserveCollapsedWhitespace(children, style) {
-    if (style.whiteSpace === WhiteSpace.Pre || style.whiteSpace === WhiteSpace.PreWrap) {
-        return true;
-    }
-    const lastChild = children.length > 0 ? children[children.length - 1] : null;
-    return !!lastChild && isInlineDisplay(lastChild.style.display);
-}
-function extractCssUrl(raw) {
-    const trimmed = raw.trim();
-    if (!trimmed) {
-        return "";
-    }
-    if (trimmed.startsWith("url(") && trimmed.endsWith(")")) {
-        let inner = trimmed.slice(4, -1).trim();
-        if ((inner.startsWith("'") && inner.endsWith("'")) ||
-            (inner.startsWith("\"") && inner.endsWith("\""))) {
-            inner = inner.slice(1, -1);
-        }
-        return inner;
-    }
-    if ((trimmed.startsWith("'") && trimmed.endsWith("'")) ||
-        (trimmed.startsWith("\"") && trimmed.endsWith("\""))) {
-        return trimmed.slice(1, -1);
-    }
-    return trimmed;
-}
-function isDataUri(value) {
-    return /^data:/i.test(value);
-}
-function isHttpUrl(value) {
-    return /^https?:\/\//i.test(value);
-}
-function parseSpan(raw) {
-    if (!raw)
-        return undefined;
-    const parsed = Number.parseInt(raw, 10);
-    return Number.isFinite(parsed) && parsed > 0 ? parsed : undefined;
-}
-async function loadBackgroundImage(cssUrl, context) {
-    const imageService = ImageService.getInstance(context.environment);
-    const resolvedSrc = resolveImageSource(cssUrl, context);
-    if (isHttpUrl(resolvedSrc) && !canLoadHttpResource(resolvedSrc, context)) {
-        log('dom-converter', 'warn', `Skipping remote background image (${resolvedSrc}); remote assets are not supported.`);
-        return null;
-    }
-    try {
-        let imageInfo;
-        if (isDataUri(resolvedSrc)) {
-            const comma = resolvedSrc.indexOf(",");
-            if (comma < 0) {
-                log('dom-converter', 'warn', `Unsupported data URI format for background image: ${cssUrl}`);
-                return null;
-            }
-            const meta = resolvedSrc.substring(5, comma);
-            const isBase64 = meta.endsWith(";base64");
-            const payload = resolvedSrc.substring(comma + 1);
-            const bytes = isBase64
-                ? decodeBase64ToUint8Array(payload)
-                : new TextEncoder().encode(decodeURIComponent(payload));
-            const copy = bytes.slice();
-            imageInfo = await imageService.decodeImage(copy.buffer);
-        }
-        else {
-            imageInfo = await imageService.loadImage(resolvedSrc);
-        }
-        return { info: imageInfo, resolvedSrc };
-    }
-    catch (error) {
-        log('dom-converter', 'warn', `Failed to load background image ${cssUrl}:`, error instanceof Error ? error.message : String(error));
-        return null;
-    }
-}
-async function hydrateBackgroundImages(style, context) {
-    if (!style.backgroundLayers || style.backgroundLayers.length === 0) {
-        return;
-    }
-    for (const layer of style.backgroundLayers) {
-        if (layer.kind !== "image") {
-            continue;
-        }
-        if (layer.imageInfo) {
-            continue;
-        }
-        const cssUrl = extractCssUrl(layer.url);
-        if (!cssUrl) {
-            continue;
-        }
-        const loaded = await loadBackgroundImage(cssUrl, context);
-        if (!loaded) {
-            continue;
-        }
-        layer.originalUrl = cssUrl;
-        layer.resolvedUrl = loaded.resolvedSrc;
-        layer.imageInfo = loaded.info;
-    }
-}
-export async function convertDomNode(node, cssRules, parentStyle, context) {
-    const extendedNode = node;
-    log('dom-converter', 'debug', `convertDomNode - entering function for node type: ${node.nodeType}, tagName: ${extendedNode.tagName || 'text node'}`);
-    if (node.nodeType === node.TEXT_NODE) {
-        const raw = node.textContent ?? "";
-        const collapsed = raw.replace(/\s+/g, " ").normalize("NFC");
-        const trimmed = collapsed.trim();
-        const hasPrev = hasMeaningfulPreviousSibling(node);
-        const hasNext = hasMeaningfulNextSibling(node);
-        if (trimmed.length === 0) {
-            const keepSpace = hasPrev && hasNext;
-            if (!keepSpace) {
-                return null;
-            }
-            log('dom-converter', 'debug', "convertDomNode - processing text node: (single space)");
-            const textStyle = new ComputedStyle({
-                display: Display.Inline,
-                color: parentStyle.color,
-                fontSize: parentStyle.fontSize,
-                lineHeight: cloneLineHeight(parentStyle.lineHeight),
-                fontFamily: parentStyle.fontFamily,
-                fontWeight: parentStyle.fontWeight,
-                fontStyle: parentStyle.fontStyle,
-                letterSpacing: parentStyle.letterSpacing,
-                wordSpacing: parentStyle.wordSpacing,
-                textDecorationLine: parentStyle.textDecorationLine,
-                textDecorationColor: parentStyle.textDecorationColor,
-                textDecorationStyle: parentStyle.textDecorationStyle,
-                textTransform: parentStyle.textTransform,
-                transform: parentStyle.transform,
-                textShadows: parentStyle.textShadows,
-            });
-            return new LayoutNode(textStyle, [], {
-                textContent: " ",
-                customData: {
-                    preserveLeadingSpace: true,
-                    preserveTrailingSpace: true,
-                },
-            });
-        }
-        let text = trimmed;
-        const preserveLeading = collapsed.startsWith(" ") && hasPrev;
-        const preserveTrailing = collapsed.endsWith(" ") && hasNext;
-        if (preserveLeading) {
-            text = " " + text;
-        }
-        if (preserveTrailing) {
-            text = text + " ";
-        }
-        log('dom-converter', 'debug', "convertDomNode - processing text node:", text.substring(0, 50) + (text.length > 50 ? '...' : ''));
-        const textStyle = new ComputedStyle({
-            display: Display.Inline,
-            color: parentStyle.color,
-            fontSize: parentStyle.fontSize,
-            lineHeight: cloneLineHeight(parentStyle.lineHeight),
-            fontFamily: parentStyle.fontFamily,
-            fontWeight: parentStyle.fontWeight,
-            fontStyle: parentStyle.fontStyle,
-            letterSpacing: parentStyle.letterSpacing,
-            wordSpacing: parentStyle.wordSpacing,
-            textDecorationLine: parentStyle.textDecorationLine,
-            textDecorationColor: parentStyle.textDecorationColor,
-            textDecorationStyle: parentStyle.textDecorationStyle,
-            textTransform: parentStyle.textTransform,
-            transform: parentStyle.transform,
-            textShadows: parentStyle.textShadows,
-        });
-        return new LayoutNode(textStyle, [], {
-            textContent: text,
-            customData: {
-                preserveLeadingSpace: preserveLeading,
-                preserveTrailingSpace: preserveTrailing,
-            },
-        });
-    }
-    if (node.nodeType !== node.ELEMENT_NODE)
-        return null;
-    const element = node;
-    const tagName = element.tagName.toLowerCase();
-    log('dom-converter', 'debug', `convertDomNode - processing element: ${tagName}, with style attr: ${element.getAttribute("style")}`);
-    if (tagName === "script" || tagName === "style")
-        return null;
-    // Handle image elements
-    if (tagName === "img") {
-        return await convertImageElement(element, cssRules, parentStyle, context);
-    }
-    if (tagName === "svg") {
-        const ownStyle = computeStyleForElement(element, cssRules, parentStyle, context.units, context.rootFontSize);
-        log('dom-converter', 'debug', "convertDomNode - computed style backgroundLayers:", ownStyle.backgroundLayers);
-        const svgRoot = parseSvg(element, { warn: (message) => log('svg-parser', 'warn', message) });
-        if (!svgRoot) {
-            return new LayoutNode(ownStyle, [], { tagName });
-        }
-        const intrinsic = resolveSvgIntrinsicSize(svgRoot, element);
-        return new LayoutNode(ownStyle, [], {
-            tagName,
-            intrinsicInlineSize: intrinsic.width,
-            intrinsicBlockSize: intrinsic.height,
-            customData: {
-                svg: {
-                    root: svgRoot,
-                    intrinsicWidth: intrinsic.width,
-                    intrinsicHeight: intrinsic.height,
-                    resourceBaseDir: context?.resourceBaseDir,
-                    assetRootDir: context?.assetRootDir,
-                },
-            },
-        });
-    }
-    if (tagName === "br") {
-        const textStyle = new ComputedStyle({
-            display: Display.Inline,
-            color: parentStyle.color,
-            fontSize: parentStyle.fontSize,
-            lineHeight: cloneLineHeight(parentStyle.lineHeight),
-            fontFamily: parentStyle.fontFamily,
-            fontWeight: parentStyle.fontWeight,
-            fontStyle: parentStyle.fontStyle,
-            textTransform: parentStyle.textTransform,
-        });
-        return new LayoutNode(textStyle, [], { textContent: "\n" });
-    }
-    if (defaultFormRegistry.isFormElement(tagName)) {
-        const formControlData = extractFormControlData(element, tagName);
-        if (formControlData) {
-            const ownStyle = computeStyleForElement(element, cssRules, parentStyle, context.units, context.rootFontSize);
-            await hydrateBackgroundImages(ownStyle, context);
-            const options = { tagName };
-            const id = element.getAttribute("id");
-            if (id) {
-                options.customData = { id, formControl: formControlData };
-            }
-            else {
-                options.customData = { formControl: formControlData };
-            }
-            return new LayoutNode(ownStyle, [], options);
-        }
-    }
-    // ✅ Coalescing de #text
-    const ownStyle = computeStyleForElement(element, cssRules, parentStyle, context.units, context.rootFontSize);
-    await hydrateBackgroundImages(ownStyle, context);
-    log('dom-converter', 'debug', "convertDomNode - computed style backgroundLayers:", ownStyle.backgroundLayers);
-    // Log if this is the div element that should have the gradient
-    if (element.tagName.toLowerCase() === 'div' && element.getAttribute("style")?.includes('linear-gradient')) {
-        log('dom-converter', 'debug', "Found div with gradient style!");
-    }
-    const layoutChildren = [];
-    let textBuf = "";
-    const childNodes = element.childNodes;
-    if (!childNodes) {
-        return new LayoutNode(ownStyle, [], { tagName });
-    }
-    for (const child of Array.from(childNodes)) {
-        if (child.nodeType === child.TEXT_NODE) {
-            textBuf += child.textContent ?? "";
-            continue;
-        }
-        if (textBuf) {
-            let normalized = textBuf.replace(/\s+/g, " ").normalize("NFC");
-            if (normalized.trim().length === 0) {
-                normalized = shouldPreserveCollapsedWhitespace(layoutChildren, ownStyle) ? " " : "";
-            }
-            if (normalized) {
-                const preserveLeading = normalized.startsWith(" ");
-                const preserveTrailing = normalized.endsWith(" ");
-                layoutChildren.push(new LayoutNode(new ComputedStyle({
-                    display: Display.Inline,
-                    color: ownStyle.color,
-                    fontSize: ownStyle.fontSize,
-                    lineHeight: cloneLineHeight(ownStyle.lineHeight),
-                    fontFamily: ownStyle.fontFamily,
-                    fontWeight: ownStyle.fontWeight,
-                    fontStyle: ownStyle.fontStyle,
-                    letterSpacing: ownStyle.letterSpacing,
-                    wordSpacing: ownStyle.wordSpacing,
-                    overflowWrap: ownStyle.overflowWrap,
-                    whiteSpace: ownStyle.whiteSpace,
-                    textDecorationLine: ownStyle.textDecorationLine,
-                    textDecorationColor: ownStyle.textDecorationColor,
-                    textDecorationStyle: ownStyle.textDecorationStyle,
-                    textTransform: ownStyle.textTransform,
-                    transform: ownStyle.transform,
-                    textShadows: ownStyle.textShadows,
-                }), [], {
-                    textContent: normalized,
-                    customData: {
-                        preserveLeadingSpace: preserveLeading,
-                        preserveTrailingSpace: preserveTrailing,
-                    },
-                }));
-            }
-            textBuf = "";
-        }
-        const sub = await convertDomNode(child, cssRules, ownStyle, context);
-        if (sub)
-            layoutChildren.push(sub);
-    }
-    if (textBuf) {
-        let normalized = textBuf.replace(/\s+/g, " ").normalize("NFC");
-        if (normalized.trim().length === 0) {
-            normalized = shouldPreserveCollapsedWhitespace(layoutChildren, ownStyle) ? " " : "";
-        }
-        if (normalized) {
-            const preserveLeading = normalized.startsWith(" ");
-            const preserveTrailing = normalized.endsWith(" ");
-            layoutChildren.push(new LayoutNode(new ComputedStyle({
-                display: Display.Inline,
-                color: ownStyle.color,
-                fontSize: ownStyle.fontSize,
-                lineHeight: cloneLineHeight(ownStyle.lineHeight),
-                fontFamily: ownStyle.fontFamily,
-                fontWeight: ownStyle.fontWeight,
-                fontStyle: ownStyle.fontStyle,
-                letterSpacing: ownStyle.letterSpacing,
-                wordSpacing: ownStyle.wordSpacing,
-                overflowWrap: ownStyle.overflowWrap,
-                whiteSpace: ownStyle.whiteSpace,
-                textDecorationLine: ownStyle.textDecorationLine,
-                textDecorationColor: ownStyle.textDecorationColor,
-                textDecorationStyle: ownStyle.textDecorationStyle,
-                textTransform: ownStyle.textTransform,
-                transform: ownStyle.transform,
-                textShadows: ownStyle.textShadows,
-            }), [], {
-                textContent: normalized,
-                customData: {
-                    preserveLeadingSpace: preserveLeading,
-                    preserveTrailingSpace: preserveTrailing,
-                },
-            }));
-        }
-    }
-    // Preserve the original HTML ID
-    const id = element.getAttribute("id");
-    const options = { tagName };
-    if (tagName === "td" || tagName === "th") {
-        options.tableColSpan = parseSpan(element.getAttribute("colspan")) ?? 1;
-        options.tableRowSpan = parseSpan(element.getAttribute("rowspan")) ?? 1;
-    }
-    if (id) {
-        options.customData = { ...options.customData, id };
-    }
-    return new LayoutNode(ownStyle, layoutChildren, options);
-}
-function resolveSvgIntrinsicSize(svg, element) {
-    let width = svg.width;
-    let height = svg.height;
-    if (svg.viewBox) {
-        if (!width || width <= 0) {
-            width = svg.viewBox.width;
-        }
-        if (!height || height <= 0) {
-            height = svg.viewBox.height;
-        }
-    }
-    if (!width || width <= 0) {
-        width = attributeToNumber(element.getAttribute("width")) ?? 100;
-    }
-    if (!height || height <= 0) {
-        height = attributeToNumber(element.getAttribute("height")) ?? width;
-    }
-    return {
-        width: Number.isFinite(width) && width > 0 ? width : 100,
-        height: Number.isFinite(height) && height > 0 ? height : 100,
-    };
-}
-function attributeToNumber(raw) {
-    if (!raw) {
-        return undefined;
-    }
-    const value = Number.parseFloat(raw);
-    return Number.isFinite(value) ? value : undefined;
-}
+export { convertDomNode } from "./dom-converter/index.js";

package/dist/src/html/image-converter.d.ts

@@ -2,12 +2,17 @@ import { type DomEl, type CssRuleEntry } from "./css/parse-css.js";
 import { LayoutNode } from "../dom/node.js";
 import { ComputedStyle } from "../css/style.js";
 import type { UnitParsers } from "../units/units.js";
+import type { CounterContext } from "../layout/counter.js";
+import type { InterBlockWhitespaceMode } from "../html-to-pdf/types.js";
 export interface ConversionContext {
     resourceBaseDir: string;
     assetRootDir: string;
     units: UnitParsers;
     rootFontSize: number;
     environment?: import("../environment/environment.js").Environment;
+    interBlockWhitespace?: InterBlockWhitespaceMode;
+    counterContext?: CounterContext;
+    rootCounterScopeId?: string | null;
 }
 export declare function resolveImageSource(src: string, context: ConversionContext): string;
 export declare function canLoadHttpResource(url: string, context: ConversionContext): boolean;

package/dist/src/html-to-pdf/document-css.d.ts

@@ -0,0 +1,14 @@
+import type { Environment } from "../environment/environment.js";
+export declare function parseInputDocument(htmlInput: string, normalizedHtml: string): Document;
+interface CollectCssArtifactsOptions {
+    document: Document;
+    cssInput: string;
+    resourceBaseDir: string;
+    assetRootDir: string;
+    environment: Environment;
+}
+export declare function collectCssArtifacts(options: CollectCssArtifactsOptions): Promise<{
+    cssRules: import("../html/css/parse-css.js").CssRuleEntry[];
+    fontFaceRules: import("../html/css/parse-css.js").FontFaceRule[];
+}>;
+export {};

package/dist/src/html-to-pdf/document-css.js

@@ -0,0 +1,45 @@
+import { log } from "../logging/debug.js";
+import { parseCss } from "../html/css/parse-css.js";
+import { loadStylesheetFromHref } from "./resource-loader.js";
+import { needsReparse, parseDocument, wrapHtml } from "./html-parser.js";
+export function parseInputDocument(htmlInput, normalizedHtml) {
+    log("html-to-pdf", "debug", `prepareHtmlRender - input html: ${htmlInput}`);
+    let document = parseDocument(normalizedHtml);
+    if (needsReparse(document)) {
+        document = parseDocument(wrapHtml(htmlInput));
+    }
+    if (!document) {
+        throw new Error("Failed to parse HTML into a document");
+    }
+    log("html-to-pdf", "debug", `prepareHtmlRender - parsed document body: ${document.body?.innerHTML || "no body"}`);
+    log("html-to-pdf", "debug", `prepareHtmlRender - document.documentElement tagName: ${document.documentElement?.tagName}`);
+    log("html-to-pdf", "debug", `prepareHtmlRender - document.documentElement innerHTML: ${document.documentElement?.innerHTML}`);
+    log("html-to-pdf", "debug", `prepareHtmlRender - document children count: ${document.childNodes.length}`);
+    for (let i = 0; i < document.childNodes.length; i++) {
+        const child = document.childNodes[i];
+        const tagName = child.nodeType === child.ELEMENT_NODE ? child.tagName : "text node";
+        log("html-to-pdf", "debug", `prepareHtmlRender - document child ${i}: ${child.nodeType}, ${tagName}`);
+    }
+    log("parse", "debug", "DOM parsed", { hasBody: !!document.body });
+    return document;
+}
+export async function collectCssArtifacts(options) {
+    let mergedCss = options.cssInput || "";
+    const styleTags = Array.from(options.document.querySelectorAll("style"));
+    for (const styleTag of styleTags) {
+        if (styleTag.textContent)
+            mergedCss += `\n${styleTag.textContent}`;
+    }
+    const linkTags = Array.from(options.document.querySelectorAll("link")).filter((link) => (link.getAttribute("rel") || "").toLowerCase() === "stylesheet");
+    for (const linkTag of linkTags) {
+        const href = linkTag.getAttribute("href");
+        if (!href)
+            continue;
+        const cssText = await loadStylesheetFromHref(href, options.resourceBaseDir, options.assetRootDir, options.environment);
+        if (cssText)
+            mergedCss += `\n${cssText}`;
+    }
+    const { styleRules: cssRules, fontFaceRules } = parseCss(mergedCss);
+    log("parse", "debug", "CSS rules", { count: cssRules.length, fontFaces: fontFaceRules.length });
+    return { cssRules, fontFaceRules };
+}

package/dist/src/html-to-pdf/fonts.d.ts

@@ -0,0 +1,16 @@
+import type { FontConfig } from "../types/fonts.js";
+import type { Environment } from "../environment/environment.js";
+export declare function pickFontUrlFromSrc(src: string): string | null;
+export declare function parseFontWeight(weightStr: string): number;
+export declare function normalizeFontStyle(styleStr: string): "normal" | "italic";
+interface ResourcePathContext {
+    resourceBaseDir: string;
+    assetRootDir: string;
+    environment: Environment;
+}
+interface ParsedFontFaceRule {
+    declarations: Record<string, string>;
+}
+export declare function appendFontFacesFromCssRules(fontFaceRules: ParsedFontFaceRule[], fontConfig: FontConfig | undefined, paths: ResourcePathContext): Promise<void>;
+export declare function ensureFontFaceDataLoaded(fontConfig: FontConfig | undefined, paths: ResourcePathContext): Promise<void>;
+export {};

package/dist/src/html-to-pdf/fonts.js

@@ -0,0 +1,74 @@
+import { loadFontData } from "./resource-loader.js";
+export function pickFontUrlFromSrc(src) {
+    const urlRegex = /url\(\s*(['"]?)([^'")]+)\1\s*\)(?:\s*format\(\s*['"]?([^'")]+)['"]?\s*\))?/gi;
+    let fallback = null;
+    let preferred = null;
+    let match;
+    while ((match = urlRegex.exec(src)) !== null) {
+        const url = match[2];
+        const format = (match[3] || "").toLowerCase();
+        if (!fallback)
+            fallback = url;
+        if (format === "woff2") {
+            preferred = url;
+            break;
+        }
+    }
+    return preferred ?? fallback;
+}
+export function parseFontWeight(weightStr) {
+    const normalized = weightStr.trim().toLowerCase();
+    if (normalized === "bold")
+        return 700;
+    if (normalized === "normal")
+        return 400;
+    const parsed = Number.parseInt(normalized, 10);
+    return Number.isFinite(parsed) ? parsed : 400;
+}
+export function normalizeFontStyle(styleStr) {
+    const normalized = styleStr.trim().toLowerCase();
+    return normalized.includes("italic") || normalized.includes("oblique") ? "italic" : "normal";
+}
+export async function appendFontFacesFromCssRules(fontFaceRules, fontConfig, paths) {
+    if (!fontConfig) {
+        return;
+    }
+    for (const fontFace of fontFaceRules) {
+        const fontFamily = fontFace.declarations["font-family"]?.replace(/['"]/g, "");
+        const src = fontFace.declarations["src"];
+        if (!fontFamily || !src) {
+            continue;
+        }
+        const targetUrl = pickFontUrlFromSrc(src);
+        if (!targetUrl) {
+            continue;
+        }
+        const fontData = await loadFontData(targetUrl, paths.resourceBaseDir, paths.assetRootDir, paths.environment);
+        if (!fontData) {
+            continue;
+        }
+        const weightStr = fontFace.declarations["font-weight"] || "400";
+        const styleStr = fontFace.declarations["font-style"] || "normal";
+        fontConfig.fontFaceDefs.push({
+            name: fontFamily,
+            family: fontFamily,
+            src: targetUrl,
+            data: fontData,
+            weight: parseFontWeight(weightStr),
+            style: normalizeFontStyle(styleStr),
+        });
+    }
+}
+export async function ensureFontFaceDataLoaded(fontConfig, paths) {
+    if (!fontConfig) {
+        return;
+    }
+    for (const face of fontConfig.fontFaceDefs) {
+        if (!face.data && face.src) {
+            const loaded = await loadFontData(face.src, paths.resourceBaseDir, paths.assetRootDir, paths.environment);
+            if (loaded) {
+                face.data = loaded;
+            }
+        }
+    }
+}

package/dist/src/html-to-pdf/header-footer.d.ts

@@ -0,0 +1,14 @@
+import type { HeaderFooterHTML } from "../pdf/types.js";
+import type { PageMarginsPx } from "../units/page-utils.js";
+import type { Environment } from "../environment/environment.js";
+interface ResolveHeaderFooterMaxHeightsOptions {
+    headerFooter?: Partial<HeaderFooterHTML>;
+    pageWidthPx: number;
+    pageHeightPx: number;
+    margins: PageMarginsPx;
+    resourceBaseDir: string;
+    assetRootDir: string;
+    environment: Environment;
+}
+export declare function resolveHeaderFooterMaxHeights(options: ResolveHeaderFooterMaxHeightsOptions): Promise<Partial<HeaderFooterHTML> | undefined>;
+export {};