pagyra-js 0.0.20 → 0.0.21

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

@@ -0,0 +1,101 @@
+import { log } from "../logging/debug.js";
+import { renderHeaderFooterHtml } from "../pdf/header-footer-renderer.js";
+const AUTO_HEADER_FOOTER_FALLBACK_PX = 64;
+export 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);
+}

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

@@ -0,0 +1,6 @@
+export declare function normalizeHtmlInput(html: string): string;
+export declare function wrapHtml(html: string): string;
+export declare function parseDocument(html: string): Document | undefined;
+export declare function needsReparse(document: Document | undefined): boolean;
+export declare function selectContentRoot(document: Document): Element | null;
+export declare function shouldSkipContentNode(node: ChildNode): boolean;

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

@@ -0,0 +1,81 @@
+import { parseHTML } from "linkedom";
+export function normalizeHtmlInput(html) {
+    const hasHtmlTag = /<\s*html[\s>]/i.test(html);
+    if (hasHtmlTag) {
+        return html;
+    }
+    return wrapHtml(html);
+}
+export function wrapHtml(html) {
+    return `<!doctype html><html><head></head><body>${html}</body></html>`;
+}
+export 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;
+}
+export 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 function selectContentRoot(document) {
+    const rootElement = document.body;
+    let processChildrenOf = rootElement;
+    if (rootElement && rootElement.childNodes.length === 0) {
+        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) {
+        processChildrenOf = document.documentElement;
+    }
+    return processChildrenOf;
+}
+export function shouldSkipContentNode(node) {
+    if (node.nodeType !== node.ELEMENT_NODE) {
+        return false;
+    }
+    const tagName = node.tagName.toLowerCase();
+    return tagName === "head" || tagName === "meta" || tagName === "title" || tagName === "link" || tagName === "script";
+}
+function isDocumentLike(value) {
+    if (!value || typeof value !== "object")
+        return false;
+    return "querySelectorAll" in value && "childNodes" in value;
+}

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

@@ -0,0 +1,3 @@
+export type { PreparedRender, RenderHtmlOptions, PagedBodyMarginMode, InterBlockWhitespaceMode, } from "./types.js";
+export { prepareHtmlRender } from "./prepare-html-render.js";
+export { renderHtmlToPdf, renderHtmlToPdfBase64 } from "./render-html-to-pdf.js";

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

@@ -0,0 +1,2 @@
+export { prepareHtmlRender } from "./prepare-html-render.js";
+export { renderHtmlToPdf, renderHtmlToPdfBase64 } from "./render-html-to-pdf.js";

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

@@ -0,0 +1,37 @@
+import { ComputedStyle } from "../css/style.js";
+import { LayoutNode } from "../dom/node.js";
+import type { CssRuleEntry } from "../html/css/parse-css.js";
+import type { ConversionContext } from "../html/image-converter.js";
+import type { UnitParsers } from "../units/units.js";
+import type { Environment } from "../environment/environment.js";
+import type { InterBlockWhitespaceMode, PagedBodyMarginMode } from "./types.js";
+interface BuildRootLayoutContextOptions {
+    document: Document;
+    cssRules: CssRuleEntry[];
+    units: UnitParsers;
+    pagedBodyMargin?: PagedBodyMarginMode;
+}
+export declare function buildRootLayoutContext(options: BuildRootLayoutContextOptions): {
+    processChildrenOf: Element | null;
+    rootStyle: ComputedStyle;
+    rootLayout: LayoutNode;
+    rootFontSize: number;
+};
+interface CreateDomConversionContextOptions {
+    resourceBaseDir: string;
+    assetRootDir: string;
+    units: UnitParsers;
+    rootFontSize: number;
+    environment: Environment;
+    interBlockWhitespace?: InterBlockWhitespaceMode;
+}
+export declare function createDomConversionContext(options: CreateDomConversionContextOptions): ConversionContext;
+interface AppendConvertedChildrenOptions {
+    processChildrenOf: Element | null;
+    rootLayout: LayoutNode;
+    cssRules: CssRuleEntry[];
+    rootStyle: ComputedStyle;
+    conversionContext: ConversionContext;
+}
+export declare function appendConvertedChildren(options: AppendConvertedChildrenOptions): Promise<void>;
+export {};

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

@@ -0,0 +1,73 @@
+import { ComputedStyle } from "../css/style.js";
+import { computeStyleForElement } from "../css/compute-style.js";
+import { Display } from "../css/enums.js";
+import { LayoutNode } from "../dom/node.js";
+import { convertDomNode } from "../html/dom-converter.js";
+import { createCounterContext } from "../layout/counter.js";
+import { log } from "../logging/debug.js";
+import { selectContentRoot, shouldSkipContentNode } from "./html-parser.js";
+export function buildRootLayoutContext(options) {
+    const processChildrenOf = selectContentRoot(options.document);
+    const baseParentStyle = new ComputedStyle();
+    const htmlElement = options.document.documentElement;
+    const documentElementStyle = htmlElement
+        ? computeStyleForElement(htmlElement, options.cssRules, baseParentStyle, options.units, baseParentStyle.fontSize)
+        : baseParentStyle;
+    const rootFontSize = documentElementStyle.fontSize;
+    let rootStyle;
+    if (!processChildrenOf || processChildrenOf === htmlElement) {
+        rootStyle = documentElementStyle;
+    }
+    else {
+        rootStyle = computeStyleForElement(processChildrenOf, options.cssRules, documentElementStyle, options.units, rootFontSize);
+    }
+    if (isInlineDisplay(rootStyle.display)) {
+        rootStyle.display = Display.Block;
+    }
+    if (options.pagedBodyMargin === "zero" && processChildrenOf?.tagName?.toLowerCase() === "body") {
+        rootStyle.marginTop = 0;
+        rootStyle.marginRight = 0;
+        rootStyle.marginBottom = 0;
+        rootStyle.marginLeft = 0;
+    }
+    const rootLayout = new LayoutNode(rootStyle, [], { tagName: processChildrenOf?.tagName?.toLowerCase() });
+    return { processChildrenOf, rootStyle, rootLayout, rootFontSize };
+}
+export function createDomConversionContext(options) {
+    const counterContext = createCounterContext();
+    const rootCounterScopeId = counterContext.registerScope(null);
+    return {
+        resourceBaseDir: options.resourceBaseDir,
+        assetRootDir: options.assetRootDir,
+        units: options.units,
+        rootFontSize: options.rootFontSize,
+        environment: options.environment,
+        interBlockWhitespace: options.interBlockWhitespace ?? "collapse",
+        counterContext,
+        rootCounterScopeId,
+    };
+}
+export async function appendConvertedChildren(options) {
+    const { processChildrenOf, rootLayout, cssRules, rootStyle, conversionContext } = options;
+    if (!processChildrenOf) {
+        return;
+    }
+    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}`);
+        if (shouldSkipContentNode(child)) {
+            continue;
+        }
+        const layoutChild = await convertDomNode(child, cssRules, rootStyle, conversionContext);
+        if (layoutChild)
+            rootLayout.appendChild(layoutChild);
+    }
+}
+function isInlineDisplay(display) {
+    return (display === Display.Inline ||
+        display === Display.InlineBlock ||
+        display === Display.InlineFlex ||
+        display === Display.InlineGrid ||
+        display === Display.InlineTable);
+}

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

@@ -0,0 +1,2 @@
+import type { PreparedRender, RenderHtmlOptions } from "./types.js";
+export declare function prepareHtmlRender(options: RenderHtmlOptions): Promise<PreparedRender>;

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

@@ -0,0 +1,121 @@
+import { configureDebug, log } from "../logging/debug.js";
+import { makeUnitParsers, pxToPt } from "../units/units.js";
+import { layoutTree } from "../layout/pipeline/layout-tree.js";
+import { buildRenderTree } from "../pdf/layout-tree-builder.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 { NodeEnvironment } from "../environment/node-environment.js";
+import { appendFontFacesFromCssRules, ensureFontFaceDataLoaded } from "./fonts.js";
+import { resolveHeaderFooterMaxHeights } from "./header-footer.js";
+import { normalizeHtmlInput } from "./html-parser.js";
+import { collectCssArtifacts, parseInputDocument } from "./document-css.js";
+import { appendConvertedChildren, buildRootLayoutContext, createDomConversionContext } from "./layout-build.js";
+import { finalizeRenderTreePositioning, initializeFontEmbedder } from "./render-finalize.js";
+export async function prepareHtmlRender(options) {
+    const pageWidth = sanitizeDimension(options.pageWidth, DEFAULT_PAGE_WIDTH_PX);
+    const pageHeight = sanitizeDimension(options.pageHeight, DEFAULT_PAGE_HEIGHT_PX);
+    const marginsPx = mergePageMargins(resolvePageMarginsPx(pageWidth, pageHeight), options.margins, 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, pagedBodyMargin = "auto", interBlockWhitespace = "collapse", } = 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);
+    const document = parseInputDocument(htmlInput, normalizedHtml);
+    const { cssRules, fontFaceRules } = await collectCssArtifacts({
+        document,
+        cssInput,
+        resourceBaseDir: resourceBaseDirVal,
+        assetRootDir: assetRootDirVal,
+        environment,
+    });
+    const { processChildrenOf, rootStyle, rootLayout, rootFontSize } = buildRootLayoutContext({
+        document,
+        cssRules,
+        units,
+        pagedBodyMargin,
+    });
+    const conversionContext = createDomConversionContext({
+        resourceBaseDir: resourceBaseDirVal,
+        assetRootDir: assetRootDirVal,
+        units,
+        rootFontSize,
+        environment,
+        interBlockWhitespace,
+    });
+    await appendConvertedChildren({
+        processChildrenOf,
+        rootLayout,
+        cssRules,
+        rootStyle,
+        conversionContext,
+    });
+    await appendFontFacesFromCssRules(fontFaceRules, options.fontConfig, {
+        resourceBaseDir: resourceBaseDirVal,
+        assetRootDir: assetRootDirVal,
+        environment,
+    });
+    await ensureFontFaceDataLoaded(options.fontConfig, {
+        resourceBaseDir: resourceBaseDirVal,
+        assetRootDir: assetRootDirVal,
+        environment,
+    });
+    const fontEmbedder = await initializeFontEmbedder(options.fontConfig);
+    layoutTree(rootLayout, { width: viewportWidth, height: viewportHeight }, fontEmbedder);
+    log("layout", "debug", "Layout complete");
+    const renderTree = buildRenderTree(rootLayout, { headerFooter: resolvedHeaderFooter });
+    finalizeRenderTreePositioning({
+        renderTree,
+        resolvedHeaderFooter,
+        pageHeight,
+        marginsPx,
+        debug,
+    });
+    const pageSize = { widthPt: pxToPt(pageWidth), heightPt: pxToPt(pageHeight) };
+    return { layoutRoot: rootLayout, renderTree, pageSize, margins: marginsPx };
+}
+function mergePageMargins(defaults, provided, pageWidth, pageHeight) {
+    const margins = { ...defaults };
+    if (provided) {
+        for (const side of ["top", "right", "bottom", "left"]) {
+            const value = provided[side];
+            if (Number.isFinite(value)) {
+                margins[side] = Math.max(Number(value), 0);
+            }
+        }
+    }
+    const horizontalSum = margins.left + margins.right;
+    const verticalSum = margins.top + margins.bottom;
+    if (horizontalSum > pageWidth) {
+        const scale = pageWidth / (horizontalSum || 1);
+        margins.left *= scale;
+        margins.right *= scale;
+    }
+    if (verticalSum > pageHeight) {
+        const scale = pageHeight / (verticalSum || 1);
+        margins.top *= scale;
+        margins.bottom *= scale;
+    }
+    return margins;
+}

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

@@ -0,0 +1,15 @@
+import { FontEmbedder } from "../pdf/font/embedder.js";
+import type { FontConfig } from "../types/fonts.js";
+import type { HeaderFooterHTML } from "../pdf/types.js";
+import { buildRenderTree } from "../pdf/layout-tree-builder.js";
+import type { PageMarginsPx } from "../units/page-utils.js";
+export declare function initializeFontEmbedder(fontConfig: FontConfig | undefined): Promise<FontEmbedder | null>;
+interface FinalizeRenderTreePositioningOptions {
+    renderTree: ReturnType<typeof buildRenderTree>;
+    resolvedHeaderFooter: Partial<HeaderFooterHTML> | undefined;
+    pageHeight: number;
+    marginsPx: PageMarginsPx;
+    debug: boolean;
+}
+export declare function finalizeRenderTreePositioning(options: FinalizeRenderTreePositioningOptions): void;
+export {};

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

@@ -0,0 +1,27 @@
+import { FontEmbedder } from "../pdf/font/embedder.js";
+import { PdfDocument } from "../pdf/primitives/pdf-document.js";
+import { applyPageVerticalMarginsWithHf, offsetRenderTree } from "../render/offset.js";
+import { applyTextLayoutAdjustments } from "../pdf/utils/text-layout-adjuster.js";
+import { buildRenderTree } from "../pdf/layout-tree-builder.js";
+export async function initializeFontEmbedder(fontConfig) {
+    if (!fontConfig) {
+        return null;
+    }
+    const pdfDoc = new PdfDocument();
+    const fontEmbedder = new FontEmbedder(fontConfig, pdfDoc);
+    await fontEmbedder.initialize();
+    return fontEmbedder;
+}
+export function finalizeRenderTreePositioning(options) {
+    const { renderTree, resolvedHeaderFooter, pageHeight, marginsPx, debug } = options;
+    applyTextLayoutAdjustments(renderTree.root);
+    const headerHeightPx = resolvedHeaderFooter?.maxHeaderHeightPx ?? 0;
+    const footerHeightPx = resolvedHeaderFooter?.maxFooterHeightPx ?? 0;
+    applyPageVerticalMarginsWithHf(renderTree.root, {
+        pageHeight,
+        margins: marginsPx,
+        headerHeightPx,
+        footerHeightPx,
+    });
+    offsetRenderTree(renderTree.root, marginsPx.left, 0, debug);
+}

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

@@ -0,0 +1,3 @@
+import type { RenderHtmlOptions } from "./types.js";
+export declare function renderHtmlToPdf(options: RenderHtmlOptions): Promise<Uint8Array>;
+export declare function renderHtmlToPdfBase64(options: RenderHtmlOptions): Promise<string>;

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

@@ -0,0 +1,25 @@
+import { renderPdf } from "../pdf/render.js";
+import { loadBuiltinFontConfig } from "../pdf/font/builtin-fonts.js";
+import { NodeEnvironment } from "../environment/node-environment.js";
+import { encodeUint8ArrayToBase64 } from "../utils/base64.js";
+import { prepareHtmlRender } from "./prepare-html-render.js";
+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);
+}

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

@@ -0,0 +1,6 @@
+import type { Environment } from "../environment/environment.js";
+export declare function resolveLocalPath(target: string, resourceBaseDir: string, assetRootDir: string, environment: Environment): string;
+export declare function selectLocalBase(target: string, resourceBaseDir: string, assetRootDir: string): string;
+export declare function loadStylesheetFromHref(href: string, resourceBaseDir: string, assetRootDir: string, environment: Environment): Promise<string>;
+export declare function rewriteCssUrls(cssText: string, baseHref: string): string;
+export declare function loadFontData(src: string, resourceBaseDir: string, assetRootDir: string, environment: Environment): Promise<ArrayBuffer | null>;

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

@@ -0,0 +1,120 @@
+import { log } from "../logging/debug.js";
+import { decodeBase64ToUint8Array } from "../utils/base64.js";
+export 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;
+}
+export function selectLocalBase(target, resourceBaseDir, assetRootDir) {
+    if (target.trim().startsWith("/")) {
+        return assetRootDir || resourceBaseDir;
+    }
+    return resourceBaseDir || assetRootDir;
+}
+export 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 "";
+    }
+}
+export 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;
+        }
+    });
+}
+export 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;
+            return await environment.loader.load(localPath);
+        }
+        const localBase = selectLocalBase(target, resourceBaseDir, assetRootDir);
+        const resolved = environment.resolveLocal
+            ? environment.resolveLocal(target, localBase || undefined)
+            : resolveLocalPath(target, resourceBaseDir, assetRootDir, environment);
+        return await environment.loader.load(resolved);
+    }
+    catch (error) {
+        log("font", "warn", "Failed to load font data", { src, error: error instanceof Error ? error.message : String(error) });
+        return null;
+    }
+}