pagyra-js 0.0.19 → 0.0.21

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

@@ -0,0 +1,38 @@
+import type { FontConfig } from "../types/fonts.js";
+import type { LogLevel } from "../logging/debug.js";
+import { LayoutNode } from "../dom/node.js";
+import { buildRenderTree } from "../pdf/layout-tree-builder.js";
+import type { PageMarginsPx } from "../units/page-utils.js";
+import type { HeaderFooterHTML } from "../pdf/types.js";
+import type { Environment } from "../environment/environment.js";
+export type PagedBodyMarginMode = "auto" | "zero";
+export type InterBlockWhitespaceMode = "collapse" | "preserve";
+export interface RenderHtmlOptions {
+    html: string;
+    css?: string;
+    viewportWidth?: number;
+    viewportHeight?: number;
+    pageWidth?: number;
+    pageHeight?: number;
+    margins?: Partial<PageMarginsPx>;
+    debug?: boolean;
+    debugLevel?: LogLevel;
+    debugCats?: string[];
+    fontConfig?: FontConfig;
+    resourceBaseDir?: string;
+    assetRootDir?: string;
+    headerFooter?: Partial<HeaderFooterHTML>;
+    pagedBodyMargin?: PagedBodyMarginMode;
+    interBlockWhitespace?: InterBlockWhitespaceMode;
+    /** Environment abstraction (Node/browser). Defaults to Node implementation. */
+    environment?: Environment;
+}
+export interface PreparedRender {
+    layoutRoot: LayoutNode;
+    renderTree: ReturnType<typeof buildRenderTree>;
+    pageSize: {
+        widthPt: number;
+        heightPt: number;
+    };
+    margins: PageMarginsPx;
+}

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

@@ -0,0 +1,2 @@
+import { LayoutNode } from "../dom/node.js";
+import { buildRenderTree } from "../pdf/layout-tree-builder.js";

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

@@ -1,37 +1 @@
-import { type FontConfig } from "./types/fonts.js";
-import { type LogLevel } from "./logging/debug.js";
-import { LayoutNode } from "./dom/node.js";
-import { buildRenderTree } from "./pdf/layout-tree-builder.js";
-import { type PageMarginsPx } from "./units/page-utils.js";
-import type { HeaderFooterHTML } from "./pdf/types.js";
-import type { Environment } from "./environment/environment.js";
-export interface RenderHtmlOptions {
-    html: string;
-    css?: string;
-    viewportWidth?: number;
-    viewportHeight?: number;
-    pageWidth?: number;
-    pageHeight?: number;
-    margins?: Partial<PageMarginsPx>;
-    debug?: boolean;
-    debugLevel?: LogLevel;
-    debugCats?: string[];
-    fontConfig?: FontConfig;
-    resourceBaseDir?: string;
-    assetRootDir?: string;
-    headerFooter?: Partial<HeaderFooterHTML>;
-    /** Environment abstraction (Node/browser). Defaults to Node implementation. */
-    environment?: Environment;
-}
-export interface PreparedRender {
-    layoutRoot: LayoutNode;
-    renderTree: ReturnType<typeof buildRenderTree>;
-    pageSize: {
-        widthPt: number;
-        heightPt: number;
-    };
-    margins: PageMarginsPx;
-}
-export declare function renderHtmlToPdf(options: RenderHtmlOptions): Promise<Uint8Array>;
-export declare function renderHtmlToPdfBase64(options: RenderHtmlOptions): Promise<string>;
-export declare function prepareHtmlRender(options: RenderHtmlOptions): Promise<PreparedRender>;
+export * from "./html-to-pdf/index.js";

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

@@ -1,537 +1 @@
-// src/html-to-pdf.ts
-import { parseHTML } from "linkedom";
-import {} from "./types/fonts.js";
-import { configureDebug, log } from "./logging/debug.js";
-import { parseCss } from "./html/css/parse-css.js";
-import { makeUnitParsers, pxToPt } from "./units/units.js";
-import { LayoutNode } from "./dom/node.js";
-import { ComputedStyle } from "./css/style.js";
-import { layoutTree } from "./layout/pipeline/layout-tree.js";
-import { buildRenderTree } from "./pdf/layout-tree-builder.js";
-import { renderPdf } from "./pdf/render.js";
-import { convertDomNode } from "./html/dom-converter.js";
-import { applyPageVerticalMarginsWithHf, offsetRenderTree } from "./render/offset.js";
-import { applyTextLayoutAdjustments } from "./pdf/utils/text-layout-adjuster.js";
-import { setViewportSize } from "./css/apply-declarations.js";
-import { DEFAULT_PAGE_WIDTH_PX, DEFAULT_PAGE_HEIGHT_PX, resolvePageMarginsPx, sanitizeDimension, maxContentDimension, } from "./units/page-utils.js";
-import { computeStyleForElement } from "./css/compute-style.js";
-import { FontEmbedder } from "./pdf/font/embedder.js";
-import { PdfDocument } from "./pdf/primitives/pdf-document.js";
-import { loadBuiltinFontConfig } from "./pdf/font/builtin-fonts.js";
-import { renderHeaderFooterHtml } from "./pdf/header-footer-renderer.js";
-import { Display } from "./css/enums.js";
-import { NodeEnvironment } from "./environment/node-environment.js";
-import { decodeBase64ToUint8Array, encodeUint8ArrayToBase64 } from "./utils/base64.js";
-const AUTO_HEADER_FOOTER_FALLBACK_PX = 64;
-export async function renderHtmlToPdf(options) {
-    const environment = options.environment ?? new NodeEnvironment(options.assetRootDir ?? options.resourceBaseDir);
-    const resolvedResourceBaseDir = options.resourceBaseDir ?? options.assetRootDir ?? "";
-    const resolvedAssetRootDir = options.assetRootDir ?? resolvedResourceBaseDir;
-    const resolvedFontConfig = options.fontConfig ?? (await loadBuiltinFontConfig(environment));
-    const preparedOptions = resolvedFontConfig ? { ...options, fontConfig: resolvedFontConfig, environment } : { ...options, environment };
-    const prepared = await prepareHtmlRender(preparedOptions);
-    return renderPdf(prepared.renderTree, {
-        pageSize: prepared.pageSize,
-        fontConfig: resolvedFontConfig ?? undefined,
-        margins: prepared.margins,
-        environment,
-        resourceBaseDir: resolvedResourceBaseDir,
-        assetRootDir: resolvedAssetRootDir,
-    });
-}
-export async function renderHtmlToPdfBase64(options) {
-    const pdfBuffer = await renderHtmlToPdf(options);
-    return encodeUint8ArrayToBase64(pdfBuffer);
-}
-export async function prepareHtmlRender(options) {
-    // Apply defaults for optional parameters
-    const pageWidth = sanitizeDimension(options.pageWidth, DEFAULT_PAGE_WIDTH_PX);
-    const pageHeight = sanitizeDimension(options.pageHeight, DEFAULT_PAGE_HEIGHT_PX);
-    const marginsPx = resolvePageMarginsPx(pageWidth, pageHeight);
-    const maxContentWidth = maxContentDimension(pageWidth, marginsPx.left + marginsPx.right);
-    const maxContentHeight = maxContentDimension(pageHeight, marginsPx.top + marginsPx.bottom);
-    const viewportWidth = Math.min(sanitizeDimension(options.viewportWidth, maxContentWidth), maxContentWidth);
-    const viewportHeight = Math.min(sanitizeDimension(options.viewportHeight, maxContentHeight), maxContentHeight);
-    // eslint-disable-next-line @typescript-eslint/no-unused-vars
-    const { html, css, pageWidth: _, pageHeight: __, margins: ___, ...restOptions } = options;
-    const { html: htmlInput, css: cssInput = "" } = { html, css: css, ...restOptions };
-    const { debug = false, debugLevel, debugCats, headerFooter, resourceBaseDir, assetRootDir, environment: envOverride } = options;
-    const normalizedHtml = normalizeHtmlInput(htmlInput);
-    setViewportSize(viewportWidth, viewportHeight);
-    const resourceBaseDirVal = resourceBaseDir ?? assetRootDir ?? "";
-    const assetRootDirVal = assetRootDir ?? resourceBaseDirVal;
-    const environment = envOverride ?? new NodeEnvironment(assetRootDirVal);
-    const resolvedHeaderFooter = await resolveHeaderFooterMaxHeights({
-        headerFooter,
-        pageWidthPx: pageWidth,
-        pageHeightPx: pageHeight,
-        margins: marginsPx,
-        resourceBaseDir: resourceBaseDirVal,
-        assetRootDir: assetRootDirVal,
-        environment,
-    });
-    if (debugLevel || debugCats) {
-        configureDebug({ level: debugLevel ?? (debug ? "debug" : "info"), cats: debugCats });
-    }
-    const unitCtx = { viewport: { width: viewportWidth, height: viewportHeight } };
-    const units = makeUnitParsers(unitCtx);
-    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 });
-    let mergedCss = cssInput || "";
-    const styleTags = Array.from(document.querySelectorAll("style"));
-    for (const styleTag of styleTags) {
-        if (styleTag.textContent)
-            mergedCss += "\n" + styleTag.textContent;
-    }
-    const linkTags = Array.from(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, resourceBaseDirVal, assetRootDirVal, environment);
-        if (cssText)
-            mergedCss += "\n" + cssText;
-    }
-    const { styleRules: cssRules, fontFaceRules } = parseCss(mergedCss);
-    log("parse", "debug", "CSS rules", { count: cssRules.length, fontFaces: fontFaceRules.length });
-    // Determine the root element to process - prefer body, but fall back to documentElement if body is empty
-    let rootElement = document.body;
-    let processChildrenOf = rootElement;
-    // If body is empty but documentElement has children (like when HTML is just a fragment),
-    // process the documentElement's children instead
-    if (rootElement && rootElement.childNodes.length === 0) {
-        // Check if documentElement has meaningful children
-        const meaningfulChildren = Array.from(document.documentElement.childNodes).filter(node => {
-            return node.nodeType === node.ELEMENT_NODE && node.tagName !== 'HEAD';
-        });
-        if (meaningfulChildren.length > 0) {
-            processChildrenOf = document.documentElement;
-        }
-    }
-    else if (!rootElement) {
-        // If there's no body element, process documentElement children directly
-        processChildrenOf = document.documentElement;
-    }
-    const baseParentStyle = new ComputedStyle();
-    const htmlElement = document.documentElement;
-    const documentElementStyle = htmlElement
-        ? computeStyleForElement(htmlElement, cssRules, baseParentStyle, units, baseParentStyle.fontSize)
-        : baseParentStyle;
-    const rootFontSize = documentElementStyle.fontSize;
-    let rootStyle;
-    if (!processChildrenOf || processChildrenOf === htmlElement) {
-        rootStyle = documentElementStyle;
-    }
-    else {
-        rootStyle = computeStyleForElement(processChildrenOf, cssRules, documentElementStyle, units, rootFontSize);
-    }
-    if (isInlineDisplay(rootStyle.display)) {
-        rootStyle.display = Display.Block;
-    }
-    const rootLayout = new LayoutNode(rootStyle, [], { tagName: processChildrenOf?.tagName?.toLowerCase() });
-    const conversionContext = { resourceBaseDir: resourceBaseDirVal, assetRootDir: assetRootDirVal, units, rootFontSize, environment };
-    if (processChildrenOf) {
-        log('html-to-pdf', 'debug', `prepareHtmlRender - processing children of: ${processChildrenOf.tagName}, count: ${processChildrenOf.childNodes.length}`);
-        for (const child of Array.from(processChildrenOf.childNodes)) {
-            const childTagName = child.nodeType === child.ELEMENT_NODE ? child.tagName : 'text node';
-            log('html-to-pdf', 'debug', `prepareHtmlRender - processing child: ${childTagName}, type: ${child.nodeType}`);
-            // Skip head and other non-content elements
-            if (child.nodeType === child.ELEMENT_NODE) {
-                const tagName = child.tagName.toLowerCase();
-                if (tagName === 'head' || tagName === 'meta' || tagName === 'title' || tagName === 'link' || tagName === 'script') {
-                    continue;
-                }
-            }
-            const layoutChild = await convertDomNode(child, cssRules, rootStyle, conversionContext);
-            if (layoutChild)
-                rootLayout.appendChild(layoutChild);
-        }
-    }
-    const pdfDoc = new PdfDocument();
-    // Process @font-face rules
-    for (const fontFace of fontFaceRules) {
-        const fontFamily = fontFace.declarations['font-family']?.replace(/['"]/g, '');
-        const src = fontFace.declarations['src'];
-        if (fontFamily && src) {
-            const targetUrl = pickFontUrlFromSrc(src);
-            if (targetUrl && options.fontConfig) {
-                const fontData = await loadFontData(targetUrl, resourceBaseDirVal, assetRootDirVal, environment);
-                if (fontData) {
-                    const weightStr = fontFace.declarations["font-weight"] || "400";
-                    const styleStr = fontFace.declarations["font-style"] || "normal";
-                    options.fontConfig.fontFaceDefs.push({
-                        name: fontFamily,
-                        family: fontFamily,
-                        src: targetUrl,
-                        data: fontData,
-                        weight: parseFontWeight(weightStr),
-                        style: normalizeFontStyle(styleStr),
-                    });
-                }
-            }
-        }
-    }
-    // In a browser environment, the font data should be pre-loaded and passed in the fontConfig.
-    if (options.fontConfig) {
-        for (const face of options.fontConfig.fontFaceDefs) {
-            if (!face.data && face.src) {
-                const loaded = await loadFontData(face.src, resourceBaseDirVal, assetRootDirVal, environment);
-                if (loaded) {
-                    // Type assertion needed because face is readonly from fontFaceDefs
-                    face.data = loaded;
-                }
-            }
-        }
-    }
-    const fontEmbedder = options.fontConfig ? new FontEmbedder(options.fontConfig, pdfDoc) : null;
-    if (fontEmbedder) {
-        await fontEmbedder.initialize();
-    }
-    layoutTree(rootLayout, { width: viewportWidth, height: viewportHeight }, fontEmbedder);
-    log("layout", "debug", "Layout complete");
-    const renderTree = buildRenderTree(rootLayout, { headerFooter: resolvedHeaderFooter });
-    // Global justification pass: fix inline run positions for text-align: justify
-    applyTextLayoutAdjustments(renderTree.root);
-    // Get header/footer heights for proper content positioning
-    const headerHeightPx = resolvedHeaderFooter?.maxHeaderHeightPx ?? 0;
-    const footerHeightPx = resolvedHeaderFooter?.maxFooterHeightPx ?? 0;
-    // Apply vertical margins with header/footer space reserved
-    // This pushes content below the header and reserves space for the footer
-    applyPageVerticalMarginsWithHf(renderTree.root, {
-        pageHeight,
-        margins: marginsPx,
-        headerHeightPx,
-        footerHeightPx,
-    });
-    offsetRenderTree(renderTree.root, marginsPx.left, 0, debug);
-    const pageSize = { widthPt: pxToPt(pageWidth), heightPt: pxToPt(pageHeight) };
-    return { layoutRoot: rootLayout, renderTree, pageSize, margins: marginsPx };
-}
-function resolveLocalPath(target, resourceBaseDir, assetRootDir, environment) {
-    let result = target;
-    if (result.startsWith("file://")) {
-        result = environment.fileURLToPath ? environment.fileURLToPath(result) : result;
-    }
-    else if (result.startsWith("/")) {
-        result = environment.pathResolve ? environment.pathResolve(assetRootDir, `.${result}`) : result;
-    }
-    else if (!(environment.pathIsAbsolute ? environment.pathIsAbsolute(result) : result.includes(":"))) {
-        result = environment.pathResolve ? environment.pathResolve(resourceBaseDir, result) : result;
-    }
-    return result;
-}
-function selectLocalBase(target, resourceBaseDir, assetRootDir) {
-    if (target.trim().startsWith("/")) {
-        return assetRootDir || resourceBaseDir;
-    }
-    return resourceBaseDir || assetRootDir;
-}
-async function loadStylesheetFromHref(href, resourceBaseDir, assetRootDir, environment) {
-    const trimmed = href.trim();
-    if (!trimmed)
-        return "";
-    try {
-        if (/^https?:\/\//i.test(trimmed) || trimmed.startsWith("//")) {
-            const absoluteHref = trimmed.startsWith("//") ? `https:${trimmed}` : trimmed;
-            const response = await fetch(absoluteHref);
-            if (!response.ok) {
-                throw new Error(`HTTP ${response.status}`);
-            }
-            const cssText = await response.text();
-            return rewriteCssUrls(cssText, absoluteHref);
-        }
-        const localBase = selectLocalBase(trimmed, resourceBaseDir, assetRootDir);
-        const cssPath = environment.resolveLocal
-            ? environment.resolveLocal(trimmed, localBase || undefined)
-            : resolveLocalPath(trimmed, resourceBaseDir, assetRootDir, environment);
-        const cssBuffer = await environment.loader.load(cssPath);
-        const cssText = new TextDecoder("utf-8").decode(cssBuffer);
-        const baseHref = /^https?:\/\//i.test(cssPath) || cssPath.startsWith("file:")
-            ? cssPath
-            : (environment.pathToFileURL ? environment.pathToFileURL(cssPath) : cssPath);
-        return rewriteCssUrls(cssText, baseHref);
-    }
-    catch (error) {
-        log("parse", "warn", "Failed to load stylesheet", { href, error: error instanceof Error ? error.message : String(error) });
-        return "";
-    }
-}
-function rewriteCssUrls(cssText, baseHref) {
-    let base;
-    try {
-        base = new URL(baseHref);
-    }
-    catch {
-        return cssText;
-    }
-    const urlRegex = /url\(\s*(['"]?)([^'")]+)\1\s*\)/gi;
-    return cssText.replace(urlRegex, (match, quote, rawUrl) => {
-        const candidate = (rawUrl || "").trim();
-        if (!candidate || /^data:/i.test(candidate))
-            return match;
-        if (/^[a-z][a-z0-9+\-.]*:/i.test(candidate))
-            return match;
-        try {
-            const resolved = new URL(candidate, base).toString();
-            const q = quote || "";
-            return `url(${q}${resolved}${q})`;
-        }
-        catch {
-            return match;
-        }
-    });
-}
-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;
-}
-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;
-}
-function normalizeFontStyle(styleStr) {
-    const normalized = styleStr.trim().toLowerCase();
-    return normalized.includes("italic") || normalized.includes("oblique") ? "italic" : "normal";
-}
-async function loadFontData(src, resourceBaseDir, assetRootDir, environment) {
-    const trimmed = src.trim();
-    if (!trimmed)
-        return null;
-    let target = trimmed;
-    try {
-        if (target.startsWith("//")) {
-            target = `https:${target}`;
-        }
-        if (/^data:/i.test(target)) {
-            const commaIdx = target.indexOf(",");
-            if (commaIdx === -1) {
-                throw new Error("Invalid data URI");
-            }
-            const meta = target.slice(5, commaIdx);
-            if (!/;base64/i.test(meta)) {
-                throw new Error("Only base64-encoded data URIs are supported for fonts");
-            }
-            const data = decodeBase64ToUint8Array(target.slice(commaIdx + 1));
-            const copy = data.slice();
-            return copy.buffer;
-        }
-        if (/^https?:\/\//i.test(target)) {
-            const response = await fetch(target);
-            if (!response.ok) {
-                throw new Error(`HTTP ${response.status}`);
-            }
-            return await response.arrayBuffer();
-        }
-        if (/^file:/i.test(target)) {
-            const localPath = environment.fileURLToPath ? environment.fileURLToPath(target) : target;
-            const fontDataBuffer = await environment.loader.load(localPath);
-            return fontDataBuffer;
-        }
-        const localBase = selectLocalBase(target, resourceBaseDir, assetRootDir);
-        const resolved = environment.resolveLocal
-            ? environment.resolveLocal(target, localBase || undefined)
-            : resolveLocalPath(target, resourceBaseDir, assetRootDir, environment);
-        const fontDataBuffer = await environment.loader.load(resolved);
-        return fontDataBuffer;
-    }
-    catch (error) {
-        log("font", "warn", "Failed to load font data", { src, error: error instanceof Error ? error.message : String(error) });
-        return null;
-    }
-}
-function isInlineDisplay(display) {
-    return (display === Display.Inline ||
-        display === Display.InlineBlock ||
-        display === Display.InlineFlex ||
-        display === Display.InlineGrid ||
-        display === Display.InlineTable);
-}
-async function resolveHeaderFooterMaxHeights(options) {
-    const { headerFooter } = options;
-    if (!headerFooter) {
-        return undefined;
-    }
-    const resolved = { ...headerFooter };
-    const contentWidthPx = Math.max(1, options.pageWidthPx - options.margins.left - options.margins.right);
-    const measurementMaxHeightPx = Math.max(1, options.pageHeightPx - options.margins.top - options.margins.bottom);
-    if (!hasOwnProperty(headerFooter, "maxHeaderHeightPx")) {
-        const headerCandidates = collectHeaderVariants(headerFooter);
-        if (headerCandidates.length > 0) {
-            const measured = await measureMaxHeaderFooterVariantHeight({
-                variants: headerCandidates,
-                widthPx: contentWidthPx,
-                maxHeightPx: measurementMaxHeightPx,
-                resourceBaseDir: options.resourceBaseDir,
-                assetRootDir: options.assetRootDir,
-                environment: options.environment,
-            });
-            resolved.maxHeaderHeightPx = measured > 0 ? measured : AUTO_HEADER_FOOTER_FALLBACK_PX;
-        }
-    }
-    if (!hasOwnProperty(headerFooter, "maxFooterHeightPx")) {
-        const footerCandidates = collectFooterVariants(headerFooter);
-        if (footerCandidates.length > 0) {
-            const measured = await measureMaxHeaderFooterVariantHeight({
-                variants: footerCandidates,
-                widthPx: contentWidthPx,
-                maxHeightPx: measurementMaxHeightPx,
-                resourceBaseDir: options.resourceBaseDir,
-                assetRootDir: options.assetRootDir,
-                environment: options.environment,
-            });
-            resolved.maxFooterHeightPx = measured > 0 ? measured : AUTO_HEADER_FOOTER_FALLBACK_PX;
-        }
-    }
-    return resolved;
-}
-async function measureMaxHeaderFooterVariantHeight(options) {
-    const heights = await Promise.all(options.variants.map(async (html) => {
-        try {
-            const rendered = await renderHeaderFooterHtml({
-                html,
-                widthPx: options.widthPx,
-                maxHeightPx: options.maxHeightPx,
-                resourceBaseDir: options.resourceBaseDir,
-                assetRootDir: options.assetRootDir,
-                environment: options.environment,
-            });
-            return rendered ? Math.ceil(rendered.heightPx) : 0;
-        }
-        catch (error) {
-            log("layout", "warn", "Failed to auto-measure header/footer variant height", {
-                error: error instanceof Error ? error.message : String(error),
-            });
-            return 0;
-        }
-    }));
-    return Math.max(0, ...heights);
-}
-function collectHeaderVariants(headerFooter) {
-    const values = [
-        headerFooter.headerHtml,
-        headerFooter.headerFirstHtml,
-        headerFooter.headerEvenHtml,
-        headerFooter.headerOddHtml,
-    ];
-    return values.map(stringifyHeaderFooterContent).filter((value) => value.length > 0);
-}
-function collectFooterVariants(headerFooter) {
-    const values = [
-        headerFooter.footerHtml,
-        headerFooter.footerFirstHtml,
-        headerFooter.footerEvenHtml,
-        headerFooter.footerOddHtml,
-    ];
-    return values.map(stringifyHeaderFooterContent).filter((value) => value.length > 0);
-}
-function stringifyHeaderFooterContent(content) {
-    if (content == null) {
-        return "";
-    }
-    if (typeof content === "string") {
-        return content;
-    }
-    if (typeof content === "function") {
-        try {
-            return String(content());
-        }
-        catch {
-            return "";
-        }
-    }
-    return String(content);
-}
-function hasOwnProperty(target, key) {
-    return Object.prototype.hasOwnProperty.call(target, key);
-}
-function normalizeHtmlInput(html) {
-    const hasHtmlTag = /<\s*html[\s>]/i.test(html);
-    if (hasHtmlTag) {
-        return html;
-    }
-    return wrapHtml(html);
-}
-function wrapHtml(html) {
-    return `<!doctype html><html><head></head><body>${html}</body></html>`;
-}
-function parseDocument(html) {
-    const parsed = parseHTML(html);
-    if (!parsed || typeof parsed !== "object") {
-        return undefined;
-    }
-    if (isDocumentLike(parsed)) {
-        return parsed;
-    }
-    let maybeDocument;
-    try {
-        maybeDocument = parsed.document;
-    }
-    catch {
-        maybeDocument = undefined;
-    }
-    if (isDocumentLike(maybeDocument)) {
-        return maybeDocument;
-    }
-    return undefined;
-}
-function isDocumentLike(value) {
-    if (!value || typeof value !== "object")
-        return false;
-    return "querySelectorAll" in value && "childNodes" in value;
-}
-function needsReparse(document) {
-    if (!document)
-        return true;
-    let docEl;
-    try {
-        docEl = document.documentElement?.tagName;
-    }
-    catch {
-        return true;
-    }
-    const docIsHtml = docEl?.toUpperCase() === "HTML";
-    if (!docIsHtml)
-        return true;
-    try {
-        if (!document.body)
-            return true;
-    }
-    catch {
-        return true;
-    }
-    return false;
-}
+export * from "./html-to-pdf/index.js";

package/dist/src/image/js-png-backend.d.ts

@@ -0,0 +1,7 @@
+import type { ImageInfo } from "./types.js";
+import type { ImageDecodeOptions } from "./types.js";
+import type { PngBackend } from "./png-backend.js";
+export declare class JsPngBackend implements PngBackend {
+    private readonly pngDecoder;
+    decode(buffer: ArrayBuffer, options?: ImageDecodeOptions): Promise<ImageInfo>;
+}

package/dist/src/image/js-png-backend.js

@@ -0,0 +1,9 @@
+import { PngDecoder } from "./png-decoder.js";
+export class JsPngBackend {
+    constructor() {
+        this.pngDecoder = new PngDecoder();
+    }
+    async decode(buffer, options) {
+        return this.pngDecoder.decode(buffer, options);
+    }
+}

package/dist/src/image/png-backend.d.ts

@@ -0,0 +1,5 @@
+import type { ImageInfo } from "./types.js";
+import type { ImageDecodeOptions } from "./types.js";
+export interface PngBackend {
+    decode(buffer: ArrayBuffer, options?: ImageDecodeOptions): Promise<ImageInfo>;
+}

package/dist/src/image/png-backend.js

@@ -0,0 +1 @@
+export {};

package/dist/src/image/png-wasm-loader.d.ts

@@ -0,0 +1,5 @@
+export declare class PngWasmLoader {
+    static getOrInit(): Promise<any>;
+    static isAvailable(): Promise<boolean>;
+    static reset(): void;
+}