pagyra-js 0.0.19 → 0.0.21

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

@@ -0,0 +1,88 @@
+import { ComputedStyle } from "../../css/style.js";
+import { ImageService } from "../../image/image-service.js";
+import { log } from "../../logging/debug.js";
+import { decodeBase64ToUint8Array } from "../../utils/base64.js";
+import { canLoadHttpResource, resolveImageSource } from "../image-converter.js";
+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);
+}
+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;
+    }
+}
+export 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;
+    }
+}

package/dist/src/html/dom-converter/convert-dom-node.d.ts

@@ -0,0 +1,5 @@
+import { ComputedStyle } from "../../css/style.js";
+import { LayoutNode } from "../../dom/node.js";
+import type { CssRuleEntry } from "../css/parse-css.js";
+import type { ConversionContext } from "../image-converter.js";
+export declare function convertDomNode(node: Node, cssRules: CssRuleEntry[], parentStyle: ComputedStyle, context: ConversionContext, parentCounterScopeId?: string | null): Promise<LayoutNode | null>;

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

@@ -0,0 +1,81 @@
+import { computeStyleForElement } from "../../css/compute-style.js";
+import { ComputedStyle } from "../../css/style.js";
+import { LayoutNode } from "../../dom/node.js";
+import { log } from "../../logging/debug.js";
+import { hydrateBackgroundImages } from "./background-images.js";
+import { isIgnoredElementTag, tryHandleSpecialElement } from "./handlers/index.js";
+import { parseSpan } from "./helpers.js";
+import { registerCounterScopeForNode, synthesizePseudoElement } from "./pseudo-elements.js";
+import { convertTextDomNode } from "./text.js";
+export async function convertDomNode(node, cssRules, parentStyle, context, parentCounterScopeId = context.rootCounterScopeId ?? null) {
+    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 textNode = convertTextDomNode(node, parentStyle, {
+            interBlockWhitespace: context.interBlockWhitespace ?? "collapse",
+        });
+        if (!textNode) {
+            return null;
+        }
+        log("dom-converter", "debug", "convertDomNode - processing text node:", `${textNode.textContent?.substring(0, 50) ?? ""}${(textNode.textContent?.length ?? 0) > 50 ? "..." : ""}`);
+        return textNode;
+    }
+    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 (isIgnoredElementTag(tagName))
+        return null;
+    const specialElementNode = await tryHandleSpecialElement({
+        element,
+        tagName,
+        cssRules,
+        parentStyle,
+        context,
+    });
+    if (specialElementNode) {
+        return specialElementNode;
+    }
+    const ownStyle = computeStyleForElement(element, cssRules, parentStyle, context.units, context.rootFontSize);
+    await hydrateBackgroundImages(ownStyle, context);
+    log("dom-converter", "debug", "convertDomNode - computed style backgroundLayers:", ownStyle.backgroundLayers);
+    if (element.tagName.toLowerCase() === "div" && element.getAttribute("style")?.includes("linear-gradient")) {
+        log("dom-converter", "debug", "Found div with gradient style!");
+    }
+    const elementCounterScopeId = registerCounterScopeForNode(ownStyle, context, parentCounterScopeId) ?? undefined;
+    const currentScopeId = elementCounterScopeId ?? parentCounterScopeId;
+    const layoutChildren = [];
+    const beforePseudo = await synthesizePseudoElement(element, "::before", cssRules, ownStyle, context, currentScopeId);
+    if (beforePseudo) {
+        layoutChildren.push(beforePseudo);
+    }
+    const childNodes = element.childNodes;
+    if (!childNodes) {
+        return new LayoutNode(ownStyle, [], { tagName });
+    }
+    for (const child of Array.from(childNodes)) {
+        const sub = await convertDomNode(child, cssRules, ownStyle, context, currentScopeId);
+        if (sub) {
+            layoutChildren.push(sub);
+        }
+    }
+    const afterPseudo = await synthesizePseudoElement(element, "::after", cssRules, ownStyle, context, currentScopeId);
+    if (afterPseudo) {
+        layoutChildren.push(afterPseudo);
+    }
+    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 };
+    }
+    const layoutNode = new LayoutNode(ownStyle, layoutChildren, options);
+    if (elementCounterScopeId) {
+        layoutNode.counterScopeId = elementCounterScopeId;
+    }
+    return layoutNode;
+}

package/dist/src/html/dom-converter/handlers/br-handler.d.ts

@@ -0,0 +1,2 @@
+import type { SpecialElementHandler } from "./types.js";
+export declare const brHandler: SpecialElementHandler;

package/dist/src/html/dom-converter/handlers/br-handler.js

@@ -0,0 +1,20 @@
+import { Display } from "../../../css/enums.js";
+import { cloneLineHeight } from "../../../css/line-height.js";
+import { ComputedStyle } from "../../../css/style.js";
+import { LayoutNode } from "../../../dom/node.js";
+function createBreakNode(parentStyle) {
+    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" });
+}
+export const brHandler = ({ parentStyle }) => {
+    return createBreakNode(parentStyle);
+};

package/dist/src/html/dom-converter/handlers/form-control-handler.d.ts

@@ -0,0 +1,2 @@
+import type { SpecialElementHandler } from "./types.js";
+export declare const formControlHandler: SpecialElementHandler;

package/dist/src/html/dom-converter/handlers/form-control-handler.js

@@ -0,0 +1,28 @@
+import { computeStyleForElement } from "../../../css/compute-style.js";
+import { ComputedStyle } from "../../../css/style.js";
+import { LayoutNode } from "../../../dom/node.js";
+import { defaultFormRegistry, extractFormControlData } from "../../../dom/form-registry.js";
+import { hydrateBackgroundImages } from "../background-images.js";
+async function createFormControlNode(element, tagName, cssRules, parentStyle, context) {
+    if (!defaultFormRegistry.isFormElement(tagName)) {
+        return null;
+    }
+    const formControlData = extractFormControlData(element, tagName);
+    if (!formControlData) {
+        return null;
+    }
+    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);
+}
+export const formControlHandler = async ({ element, tagName, cssRules, parentStyle, context }) => {
+    return await createFormControlNode(element, tagName, cssRules, parentStyle, context);
+};

package/dist/src/html/dom-converter/handlers/img-handler.d.ts

@@ -0,0 +1,2 @@
+import type { SpecialElementHandler } from "./types.js";
+export declare const imgHandler: SpecialElementHandler;

package/dist/src/html/dom-converter/handlers/img-handler.js

@@ -0,0 +1,4 @@
+import { convertImageElement } from "../../image-converter.js";
+export const imgHandler = async ({ element, cssRules, parentStyle, context }) => {
+    return await convertImageElement(element, cssRules, parentStyle, context);
+};

package/dist/src/html/dom-converter/handlers/index.d.ts

@@ -0,0 +1,4 @@
+import type { LayoutNode } from "../../../dom/node.js";
+import type { SpecialElementHandlerArgs } from "./types.js";
+export declare function isIgnoredElementTag(tagName: string): boolean;
+export declare function tryHandleSpecialElement(args: SpecialElementHandlerArgs): Promise<LayoutNode | null>;

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

@@ -0,0 +1,19 @@
+import { brHandler } from "./br-handler.js";
+import { formControlHandler } from "./form-control-handler.js";
+import { imgHandler } from "./img-handler.js";
+import { svgHandler } from "./svg-handler.js";
+const exactTagHandlers = new Map([
+    ["img", imgHandler],
+    ["svg", svgHandler],
+    ["br", brHandler],
+]);
+export function isIgnoredElementTag(tagName) {
+    return tagName === "script" || tagName === "style";
+}
+export async function tryHandleSpecialElement(args) {
+    const exactHandler = exactTagHandlers.get(args.tagName);
+    if (exactHandler) {
+        return await exactHandler(args);
+    }
+    return await formControlHandler(args);
+}

package/dist/src/html/dom-converter/handlers/svg-handler.d.ts

@@ -0,0 +1,2 @@
+import type { SpecialElementHandler } from "./types.js";
+export declare const svgHandler: SpecialElementHandler;

package/dist/src/html/dom-converter/handlers/svg-handler.js

@@ -0,0 +1,32 @@
+import { computeStyleForElement } from "../../../css/compute-style.js";
+import { ComputedStyle } from "../../../css/style.js";
+import { LayoutNode } from "../../../dom/node.js";
+import { log } from "../../../logging/debug.js";
+import { parseSvg } from "../../../svg/parser.js";
+import { resolveSvgIntrinsicSize } from "../helpers.js";
+function createSvgNode(element, tagName, cssRules, parentStyle, context) {
+    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,
+            },
+        },
+    });
+}
+export const svgHandler = ({ element, tagName, cssRules, parentStyle, context }) => {
+    return createSvgNode(element, tagName, cssRules, parentStyle, context);
+};

package/dist/src/html/dom-converter/handlers/types.d.ts

@@ -0,0 +1,12 @@
+import { ComputedStyle } from "../../../css/style.js";
+import { LayoutNode } from "../../../dom/node.js";
+import type { CssRuleEntry, DomEl } from "../../css/parse-css.js";
+import type { ConversionContext } from "../../image-converter.js";
+export interface SpecialElementHandlerArgs {
+    element: DomEl;
+    tagName: string;
+    cssRules: CssRuleEntry[];
+    parentStyle: ComputedStyle;
+    context: ConversionContext;
+}
+export type SpecialElementHandler = (args: SpecialElementHandlerArgs) => Promise<LayoutNode | null> | LayoutNode | null;

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

@@ -0,0 +1,2 @@
+import { ComputedStyle } from "../../../css/style.js";
+import { LayoutNode } from "../../../dom/node.js";

package/dist/src/html/dom-converter/helpers.d.ts

@@ -0,0 +1,7 @@
+import type { SvgRootNode } from "../../svg/types.js";
+import type { SvgElement } from "../../types/core.js";
+export declare function parseSpan(raw: string | null): number | undefined;
+export declare function resolveSvgIntrinsicSize(svg: SvgRootNode, element: SvgElement): {
+    width: number;
+    height: number;
+};

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

@@ -0,0 +1,35 @@
+export function parseSpan(raw) {
+    if (!raw)
+        return undefined;
+    const parsed = Number.parseInt(raw, 10);
+    return Number.isFinite(parsed) && parsed > 0 ? parsed : undefined;
+}
+export 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;
+}

package/dist/src/html/dom-converter/index.d.ts

@@ -0,0 +1 @@
+export { convertDomNode } from "./convert-dom-node.js";

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

@@ -0,0 +1 @@
+export { convertDomNode } from "./convert-dom-node.js";

package/dist/src/html/dom-converter/pseudo-elements.d.ts

@@ -0,0 +1,6 @@
+import type { ComputedStyle } from "../../css/style.js";
+import { LayoutNode } from "../../dom/node.js";
+import type { CssPseudoElement, CssRuleEntry, DomEl } from "../css/parse-css.js";
+import type { ConversionContext } from "../image-converter.js";
+export declare function registerCounterScopeForNode(style: ComputedStyle, context: ConversionContext, parentScopeId: string | null): string | undefined;
+export declare function synthesizePseudoElement(element: DomEl, pseudoType: CssPseudoElement, cssRules: CssRuleEntry[], parentStyle: ComputedStyle, context: ConversionContext, parentCounterScopeId: string | null): Promise<LayoutNode | null>;

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

@@ -0,0 +1,48 @@
+import { evaluateContent } from "../../css/parsers/content-parser.js";
+import { LayoutNode } from "../../dom/node.js";
+import { applyCounterIncrements, applyCounterResets } from "../../layout/counter.js";
+import { computeStyleForPseudoElement } from "../../css/compute-style.js";
+import { hydrateBackgroundImages } from "./background-images.js";
+import { createGeneratedTextNode } from "./text.js";
+export function registerCounterScopeForNode(style, context, parentScopeId) {
+    if (!context.counterContext) {
+        return undefined;
+    }
+    const scopeId = context.counterContext.registerScope(parentScopeId);
+    if (style.counterReset && style.counterReset.length > 0) {
+        applyCounterResets(context.counterContext, style.counterReset, scopeId);
+    }
+    if (style.counterIncrement && style.counterIncrement.length > 0) {
+        applyCounterIncrements(context.counterContext, style.counterIncrement, scopeId);
+    }
+    return scopeId;
+}
+export async function synthesizePseudoElement(element, pseudoType, cssRules, parentStyle, context, parentCounterScopeId) {
+    const pseudoStyle = computeStyleForPseudoElement(element, cssRules, pseudoType, parentStyle, context.units, context.rootFontSize);
+    if (!pseudoStyle.content) {
+        return null;
+    }
+    await hydrateBackgroundImages(pseudoStyle, context);
+    const pseudoScopeId = registerCounterScopeForNode(pseudoStyle, context, parentCounterScopeId);
+    const effectiveScopeId = pseudoScopeId ?? parentCounterScopeId;
+    const generatedText = evaluateContent(pseudoStyle.content, {
+        getCounter: (name) => context.counterContext?.getCounter(name, effectiveScopeId) ?? 0,
+        getAttribute: (name) => element.getAttribute(name),
+        quoteDepth: 0,
+    });
+    const children = [];
+    const textNode = createGeneratedTextNode(generatedText, pseudoStyle);
+    if (textNode) {
+        children.push(textNode);
+    }
+    const pseudoNode = new LayoutNode(pseudoStyle, children, {
+        tagName: pseudoType,
+        customData: {
+            pseudoType: pseudoType === "::before" ? "before" : "after",
+        },
+    });
+    if (pseudoScopeId) {
+        pseudoNode.counterScopeId = pseudoScopeId;
+    }
+    return pseudoNode;
+}

package/dist/src/html/dom-converter/text.d.ts

@@ -0,0 +1,15 @@
+import { LayoutNode } from "../../dom/node.js";
+import { ComputedStyle } from "../../css/style.js";
+import { Display } from "../../css/enums.js";
+import type { InterBlockWhitespaceMode } from "../../html-to-pdf/types.js";
+interface TextConversionOptions {
+    interBlockWhitespace?: InterBlockWhitespaceMode;
+}
+export declare function isGridOrFlexContainer(display: Display): boolean;
+export declare function shouldPreserveCollapsedWhitespace(children: LayoutNode[], style: ComputedStyle): boolean;
+export declare function createInlineTextStyle(parentStyle: ComputedStyle): ComputedStyle;
+export declare function createInlineTextLayoutNode(text: string, parentStyle: ComputedStyle, preserveLeadingSpace: boolean, preserveTrailingSpace: boolean): LayoutNode;
+export declare function createGeneratedTextNode(text: string, parentStyle: ComputedStyle): LayoutNode | null;
+export declare function convertTextDomNode(node: Node, parentStyle: ComputedStyle, options?: TextConversionOptions): LayoutNode | null;
+export declare function flushBufferedText(layoutChildren: LayoutNode[], textBuffer: string, ownStyle: ComputedStyle): string;
+export {};

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

@@ -0,0 +1,170 @@
+import { LayoutNode } from "../../dom/node.js";
+import { ComputedStyle } from "../../css/style.js";
+import { cloneLineHeight } from "../../css/line-height.js";
+import { Display, WhiteSpace } from "../../css/enums.js";
+const BLOCK_TAGS = new Set([
+    "address", "article", "aside", "blockquote", "canvas", "dd", "div", "dl", "dt",
+    "fieldset", "figcaption", "figure", "footer", "form", "h1", "h2", "h3", "h4",
+    "h5", "h6", "header", "hr", "li", "main", "nav", "noscript", "ol", "p", "pre",
+    "section", "table", "tbody", "thead", "tfoot", "tr", "td", "th", "ul", "video",
+]);
+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 isInlineDisplay(display) {
+    return (display === Display.Inline ||
+        display === Display.InlineBlock ||
+        display === Display.InlineFlex ||
+        display === Display.InlineGrid ||
+        display === Display.InlineTable);
+}
+export function isGridOrFlexContainer(display) {
+    return (display === Display.Grid ||
+        display === Display.InlineGrid ||
+        display === Display.Flex ||
+        display === Display.InlineFlex);
+}
+export function shouldPreserveCollapsedWhitespace(children, style) {
+    if (isGridOrFlexContainer(style.display)) {
+        return false;
+    }
+    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);
+}
+export function createInlineTextStyle(parentStyle) {
+    return 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,
+        overflowWrap: parentStyle.overflowWrap,
+        wordBreak: parentStyle.wordBreak,
+        whiteSpace: parentStyle.whiteSpace,
+        textDecorationLine: parentStyle.textDecorationLine,
+        textDecorationColor: parentStyle.textDecorationColor,
+        textDecorationStyle: parentStyle.textDecorationStyle,
+        textTransform: parentStyle.textTransform,
+        transform: parentStyle.transform,
+        textShadows: parentStyle.textShadows,
+    });
+}
+export function createInlineTextLayoutNode(text, parentStyle, preserveLeadingSpace, preserveTrailingSpace) {
+    return new LayoutNode(createInlineTextStyle(parentStyle), [], {
+        textContent: text,
+        customData: {
+            preserveLeadingSpace,
+            preserveTrailingSpace,
+        },
+    });
+}
+export function createGeneratedTextNode(text, parentStyle) {
+    if (text.length === 0) {
+        return null;
+    }
+    return createInlineTextLayoutNode(text, parentStyle, true, true);
+}
+export function convertTextDomNode(node, parentStyle, options = {}) {
+    const raw = node.textContent ?? "";
+    const collapsed = raw.replace(/\s+/g, " ").normalize("NFC");
+    const trimmed = collapsed.trim();
+    const prev = findMeaningfulSibling(node.previousSibling, "previous");
+    const next = findMeaningfulSibling(node.nextSibling, "next");
+    const hasPrev = prev !== null;
+    const hasNext = next !== null;
+    const interBlockWhitespace = options.interBlockWhitespace ?? "collapse";
+    const preserveLeadingCandidate = collapsed.startsWith(" ") && hasPrev;
+    const preserveTrailingCandidate = collapsed.endsWith(" ") && hasNext;
+    const preserveLeading = preserveLeadingCandidate && shouldKeepBoundarySpace(prev, interBlockWhitespace, parentStyle);
+    const preserveTrailing = preserveTrailingCandidate && shouldKeepBoundarySpace(next, interBlockWhitespace, parentStyle);
+    if (trimmed.length === 0) {
+        if (isGridOrFlexContainer(parentStyle.display)) {
+            return null;
+        }
+        const keepSpace = hasPrev &&
+            hasNext &&
+            (interBlockWhitespace === "preserve" || shouldKeepInterSiblingWhitespace(prev, next, parentStyle));
+        if (!keepSpace) {
+            return null;
+        }
+        return createInlineTextLayoutNode(" ", parentStyle, true, true);
+    }
+    let text = trimmed;
+    if (preserveLeading) {
+        text = " " + text;
+    }
+    if (preserveTrailing) {
+        text = text + " ";
+    }
+    return createInlineTextLayoutNode(text, parentStyle, preserveLeading, preserveTrailing);
+}
+function shouldKeepBoundarySpace(sibling, mode, parentStyle) {
+    if (mode === "preserve") {
+        return true;
+    }
+    if (isInlineDisplay(parentStyle.display)) {
+        return true;
+    }
+    return isInlineLikeNode(sibling);
+}
+function shouldKeepInterSiblingWhitespace(prev, next, parentStyle) {
+    if (isInlineDisplay(parentStyle.display)) {
+        return true;
+    }
+    return isInlineLikeNode(prev) && isInlineLikeNode(next);
+}
+function isInlineLikeNode(node) {
+    if (!node) {
+        return false;
+    }
+    if (node.nodeType === node.TEXT_NODE) {
+        return true;
+    }
+    if (node.nodeType !== node.ELEMENT_NODE) {
+        return false;
+    }
+    const tagName = node.tagName.toLowerCase();
+    return !BLOCK_TAGS.has(tagName);
+}
+export function flushBufferedText(layoutChildren, textBuffer, ownStyle) {
+    if (!textBuffer) {
+        return "";
+    }
+    let normalized = textBuffer.replace(/\s+/g, " ").normalize("NFC");
+    if (normalized.trim().length === 0) {
+        normalized = shouldPreserveCollapsedWhitespace(layoutChildren, ownStyle) ? " " : "";
+    }
+    if (!normalized) {
+        return "";
+    }
+    const preserveLeading = normalized.startsWith(" ");
+    const preserveTrailing = normalized.endsWith(" ");
+    layoutChildren.push(createInlineTextLayoutNode(normalized, ownStyle, preserveLeading, preserveTrailing));
+    return "";
+}

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

@@ -1,5 +1 @@
-import { type CssRuleEntry } from "./css/parse-css.js";
-import { LayoutNode } from "../dom/node.js";
-import { ComputedStyle } from "../css/style.js";
-import { type ConversionContext } from "./image-converter.js";
-export declare function convertDomNode(node: Node, cssRules: CssRuleEntry[], parentStyle: ComputedStyle, context: ConversionContext): Promise<LayoutNode | null>;
+export { convertDomNode } from "./dom-converter/index.js";