pagyra-js 0.0.21 → 0.0.23

package/dist/src/render/offset.d.ts

@@ -12,6 +12,11 @@ export interface PageVerticalMarginsOptions {
     /** Footer height in pixels (reduces available content area) */
     footerHeightPx?: number;
 }
+/**
+ * Handles 'break-inside: avoid' by pushing content to the next page
+ * when a box would otherwise cross a page boundary.
+ */
+export declare function applyBreakInsideAvoid(root: RenderBox, usablePageHeight: number): void;
 export declare function applyPageVerticalMargins(root: RenderBox, pageHeight: number, margins: PageMarginsPx): void;
 /**
  * Applies vertical margins and header/footer offsets to the render tree.

package/dist/src/render/offset.js

@@ -7,6 +7,20 @@ export function offsetRect(rect, dx, dy) {
     rect.x += dx;
     rect.y += dy;
 }
+function offsetClipPath(box, dx, dy) {
+    if (!box.clipPath)
+        return;
+    if (box.clipPath.type === "polygon") {
+        for (const point of box.clipPath.points) {
+            point.x += dx;
+            point.y += dy;
+        }
+    }
+    else if (box.clipPath.type === "ellipse") {
+        box.clipPath.cx += dx;
+        box.clipPath.cy += dy;
+    }
+}
 function offsetBackground(background, dx, dy) {
     if (!background) {
         return;
@@ -36,15 +50,14 @@ export function offsetRenderTree(root, dx, dy, _debug) {
         offsetRect(box.paddingBox, dx, dy);
         offsetRect(box.borderBox, dx, dy);
         offsetRect(box.visualOverflow, dx, dy);
-        if (box.clipPath && box.clipPath.points) {
-            for (const point of box.clipPath.points) {
-                point.x += dx;
-                point.y += dy;
-            }
-        }
+        offsetClipPath(box, dx, dy);
         if (box.markerRect) {
             offsetRect(box.markerRect, dx, dy);
         }
+        if (box.maskGradient) {
+            offsetRect(box.maskGradient.rect, dx, dy);
+            offsetRect(box.maskGradient.originRect, dx, dy);
+        }
         offsetBackground(box.background, dx, dy);
         for (const link of box.links) {
             offsetRect(link.rect, dx, dy);
@@ -60,6 +73,68 @@ export function offsetRenderTree(root, dx, dy, _debug) {
         }
     }
 }
+/**
+ * Handles 'break-inside: avoid' by pushing content to the next page
+ * when a box would otherwise cross a page boundary.
+ */
+export function applyBreakInsideAvoid(root, usablePageHeight) {
+    let globalOffset = 0;
+    function traverse(box) {
+        // Apply cumulative offset from previous breaks
+        if (globalOffset > 0) {
+            offsetBox(box, 0, globalOffset);
+        }
+        const rect = box.borderBox ?? box.contentBox;
+        const top = rect.y;
+        const bottom = rect.y + rect.height;
+        const startPage = Math.floor(top / usablePageHeight);
+        const endPage = Math.floor((bottom - 0.001) / usablePageHeight);
+        if (box.breakInside === "avoid" && startPage !== endPage) {
+            const nextPageTop = (startPage + 1) * usablePageHeight;
+            const pushDown = nextPageTop - top;
+            if (pushDown > 0) {
+                log("layout", "debug", `break-inside: avoid triggered for ${box.tagName} id:${box.id}. Pushing down by ${pushDown}px`, {
+                    tagName: box.tagName,
+                    id: box.id,
+                    top,
+                    bottom,
+                    nextPageTop,
+                });
+                offsetBox(box, 0, pushDown);
+                globalOffset += pushDown;
+            }
+        }
+        // Recurse into children. They will be shifted by current globalOffset.
+        for (const child of box.children) {
+            traverse(child);
+        }
+    }
+    function offsetBox(box, dx, dy) {
+        offsetRect(box.contentBox, dx, dy);
+        offsetRect(box.paddingBox, dx, dy);
+        offsetRect(box.borderBox, dx, dy);
+        offsetRect(box.visualOverflow, dx, dy);
+        offsetClipPath(box, dx, dy);
+        if (box.markerRect) {
+            offsetRect(box.markerRect, dx, dy);
+        }
+        if (box.maskGradient) {
+            offsetRect(box.maskGradient.rect, dx, dy);
+            offsetRect(box.maskGradient.originRect, dx, dy);
+        }
+        offsetBackground(box.background, dx, dy);
+        for (const link of box.links) {
+            offsetRect(link.rect, dx, dy);
+        }
+        for (const run of box.textRuns) {
+            if (run.lineMatrix) {
+                run.lineMatrix.e += dx;
+                run.lineMatrix.f += dy;
+            }
+        }
+    }
+    traverse(root);
+}
 export function applyPageVerticalMargins(root, pageHeight, margins) {
     applyPageVerticalMarginsWithHf(root, { pageHeight, margins });
 }
@@ -119,14 +194,23 @@ export function applyPageVerticalMarginsWithHf(root, options) {
         adjustRect(box.paddingBox);
         adjustRect(box.borderBox);
         adjustRect(box.visualOverflow);
-        if (box.clipPath && box.clipPath.points) {
-            for (const point of box.clipPath.points) {
-                point.y = mapY(point.y);
+        if (box.clipPath) {
+            if (box.clipPath.type === "polygon") {
+                for (const point of box.clipPath.points) {
+                    point.y = mapY(point.y);
+                }
+            }
+            else if (box.clipPath.type === "ellipse") {
+                box.clipPath.cy = mapY(box.clipPath.cy);
             }
         }
         if (box.markerRect) {
             adjustRect(box.markerRect);
         }
+        if (box.maskGradient) {
+            adjustRect(box.maskGradient.rect);
+            adjustRect(box.maskGradient.originRect);
+        }
         adjustBackground(box.background);
         for (const link of box.links) {
             adjustRect(link.rect);

package/dist/src/text/line-breaker.js

@@ -91,6 +91,34 @@ function enforceOverflowWrap(items, style, availableWidth, mode) {
     }
     return adjusted.length ? adjusted : items;
 }
+// Splits any word wider than the available width, regardless of the overflow-wrap mode.
+// Unlike enforceOverflowWrap (which only acts for break-word/anywhere), this is a safety net to
+// keep an over-long, otherwise-unbreakable token (e.g. a long URL) from running off the page.
+function enforceEmergencyBreak(items, style, availableWidth) {
+    if (!(availableWidth > 0)) {
+        return items;
+    }
+    let needsBreak = false;
+    for (const item of items) {
+        if (item.type === "word" && item.width > availableWidth) {
+            needsBreak = true;
+            break;
+        }
+    }
+    if (!needsBreak) {
+        return items;
+    }
+    const adjusted = [];
+    for (const item of items) {
+        if (item.type === "word" && item.width > availableWidth) {
+            adjusted.push(...splitWordItem(item, style, availableWidth));
+        }
+        else {
+            adjusted.push(item);
+        }
+    }
+    return adjusted.length ? adjusted : items;
+}
 function countJustifiableSpaces(items) {
     let count = 0;
     for (let index = 0; index < items.length; index++) {
@@ -156,6 +184,9 @@ export function breakTextIntoLines(text, style, availableWidth, fontEmbedder = n
     const rawItems = segmentText(effectiveText);
     let items = measureItems(rawItems, style, fontEmbedder);
     items = enforceOverflowWrap(items, style, availableWidth, style.overflowWrap);
+    // Last-resort break: a single word wider than the whole line would otherwise overflow off the
+    // page (lost content in a fixed-size PDF). Break it to fit even when overflow-wrap is `normal`.
+    items = enforceEmergencyBreak(items, style, availableWidth);
     const n = items.length;
     if (n === 0)
         return [];

package/dist/tests/css/clip-path-parser.spec.js

@@ -12,18 +12,23 @@ describe("clip-path parser", () => {
         parseClipPath("polygon(50% 0, 0 100%, 100% 100%)", target);
         expect(target.clipPath).toBeDefined();
         expect(target.clipPath?.type).toBe("polygon");
-        const points = target.clipPath?.points;
-        expect(points).toBeDefined();
-        expect(points?.length).toBe(3);
-        expect(points?.[0].x.unit).toBe("percent");
-        expect(points?.[1].y.unit).toBe("percent");
+        const clip = target.clipPath;
+        expect(clip.type).toBe("polygon");
+        if (clip.type !== "polygon")
+            return;
+        expect(clip.points).toBeDefined();
+        expect(clip.points.length).toBe(3);
+        expect(clip.points[0].x.unit).toBe("percent");
+        expect(clip.points[1].y.unit).toBe("percent");
     });
     it("parses polygon clip-path with px units", () => {
         const target = {};
         parseClipPath("polygon(0px 0px, 100px 0px, 0px 100px)", target);
         expect(target.clipPath).toBeDefined();
-        expect(target.clipPath?.points[2].y.unit).toBe("px");
-        expect(target.clipPath?.points[2].y.value).toBe(100);
+        if (target.clipPath?.type !== "polygon")
+            return;
+        expect(target.clipPath.points[2].y.unit).toBe("px");
+        expect(target.clipPath.points[2].y.value).toBe(100);
     });
     it("ignores unsupported clip-path values", () => {
         const target = {};
@@ -56,6 +61,8 @@ describe("clip-path parser", () => {
         const style = computeStyleForElement(element, [], new ComputedStyle(), makeUnitParsers({ viewport: { width: 800, height: 600 } }), 16);
         expect(style.clipPath).toBeDefined();
         expect(style.clipPath?.type).toBe("polygon");
-        expect(style.clipPath?.points).toHaveLength(3);
+        if (style.clipPath?.type !== "polygon")
+            return;
+        expect(style.clipPath.points).toHaveLength(3);
     });
 });

package/dist/tests/environment/path-resolution.spec.js

@@ -1,9 +1,10 @@
 import { NodeEnvironment } from '../../src/environment/node-environment.js';
 import { BrowserEnvironment } from '../../src/environment/browser-environment.js';
 import path from 'node:path';
+import { fileURLToPath } from 'node:url';
 describe('Path Resolution', () => {
     describe('NodeEnvironment', () => {
-        const toPath = (p) => p.startsWith('file:') ? require('node:url').fileURLToPath(p) : p;
+        const toPath = (p) => p.startsWith('file:') ? fileURLToPath(p) : p;
         it('resolves leading-slash paths relative to base', () => {
             const env = new NodeEnvironment();
             const base = path.resolve('/var/www/public');

package/dist/tests/helpers/ai-layout-diagnostics.js

@@ -51,12 +51,12 @@ export function renderAsciiLayout() {
     const contentH = Math.round(contentBox.height);
     const spanW = Math.round(spanBox.width);
     const spanH = Math.round(spanBox.height);
-    const ascii = `Border Box (W:${borderW}, H:${borderH}) |#########################|
-Content Box at (${Math.round(contentX)}, ${Math.round(contentY)}) (W:${contentW}, H:${contentH}) |   +---+   |
-|   |###|   |
-|   +---+   |
-Span Box at (${Math.round(spanX)}, ${Math.round(spanY)}) (W:${spanW}, H:${spanH}) |   [xxx]   |
-Padding: T:${padding.top}, R:${padding.right}, B:${padding.bottom}, L:${padding.left}
+    const ascii = `Border Box (W:${borderW}, H:${borderH}) |#########################|
+Content Box at (${Math.round(contentX)}, ${Math.round(contentY)}) (W:${contentW}, H:${contentH}) |   +---+   |
+|   |###|   |
+|   +---+   |
+Span Box at (${Math.round(spanX)}, ${Math.round(spanY)}) (W:${spanW}, H:${spanH}) |   [xxx]   |
+Padding: T:${padding.top}, R:${padding.right}, B:${padding.bottom}, L:${padding.left}
 Border: T:${border.top}, R:${border.right}, B:${border.bottom}, L:${border.left}`;
     context.ascii = ascii;
     return ascii;

package/dist/tests/layout/container-query-units.spec.js

@@ -1,11 +1,4 @@
 import { collectBoxes, renderTreeForHtml } from "../helpers/render-utils.js";
-function findByTag(boxes, tagName) {
-    const found = boxes.find((b) => b.tagName === tagName);
-    if (!found) {
-        throw new Error(`Expected to find <${tagName}> in render tree`);
-    }
-    return found;
-}
 describe("container query unit layout", () => {
     it("resolves cqw/cqh/cqmin/cqmax against containing block dimensions", async () => {
         const html = "<!DOCTYPE html><html><body style=\"margin:0;\"><section style=\"width:400px;height:300px;\"><div id=\"a\" style=\"width:50cqw;height:25cqh;\"></div><div id=\"b\" style=\"width:10cqmin;height:10cqmax;\"></div></section></body></html>";

package/dist/tests/layout/inline-background-alignment.spec.js

@@ -5,8 +5,8 @@ const POSITION_TOLERANCE_PX = 10;
 const WIDTH_TOLERANCE_RATIO = 0.9;
 describe("inline background alignment", () => {
     it("aligns background with text for inline span elements", async () => {
-        const html = `
-            <p>Normal text <span style="background-color: yellow">highlighted text</span> after.</p>
+        const html = `
+            <p>Normal text <span style="background-color: yellow">highlighted text</span> after.</p>
         `;
         const renderTree = await renderTreeForHtml(html);
         const boxes = collectBoxes(renderTree.root);
@@ -28,8 +28,8 @@ describe("inline background alignment", () => {
         }
     });
     it("calculates correct width for inline span with multiple text fragments", async () => {
-        const html = `
-            <p>Before <span style="background-color: lightblue">text one two three</span> after.</p>
+        const html = `
+            <p>Before <span style="background-color: lightblue">text one two three</span> after.</p>
         `;
         const renderTree = await renderTreeForHtml(html);
         const boxes = collectBoxes(renderTree.root);
@@ -56,8 +56,8 @@ describe("inline background alignment", () => {
         }
     });
     it("positions background correctly when span follows other content", async () => {
-        const html = `
-            <p>Some initial text <span style="background-color: pink">highlighted</span> end.</p>
+        const html = `
+            <p>Some initial text <span style="background-color: pink">highlighted</span> end.</p>
         `;
         const renderTree = await renderTreeForHtml(html);
         const boxes = collectBoxes(renderTree.root);

package/dist/tests/layout/table-image-cell.spec.js

@@ -0,0 +1,95 @@
+import { describe, it, expect } from "vitest";
+import { collectBoxes, collectRuns, renderTreeForHtml } from "../helpers/render-utils.js";
+// Minimal valid 1×1 PNG used as image payload; intrinsic dimensions are
+// overridden by the HTML width/height attributes in each test.
+const ONE_BY_ONE_PNG = "iVBORw0KGgoAAAANSUhEUgAAAAEAAAABCAIAAACQd1PeAAAADUlEQVR42mP8/5+hHgAHggJ/P95syQAAAABJRU5ErkJggg==";
+describe("table cell with image content", () => {
+    it("row height equals the image height when the left cell contains only an image", async () => {
+        const html = `
+      <table>
+        <tr>
+          <td><img src="data:image/png;base64,${ONE_BY_ONE_PNG}" width="60" height="80" /></td>
+          <td><p style="font-size:12px;margin:0">Short text</p></td>
+        </tr>
+      </table>
+    `;
+        const tree = await renderTreeForHtml(html);
+        const boxes = collectBoxes(tree.root);
+        const table = boxes.find((b) => b.tagName === "table");
+        expect(table).toBeDefined();
+        // The row height must accommodate the 80px-tall image.
+        expect(table.contentBox.height).toBeGreaterThanOrEqual(80);
+    });
+    it("image-only cell has non-zero content height and the row has matching height", async () => {
+        const html = `
+      <table>
+        <tr>
+          <td><img src="data:image/png;base64,${ONE_BY_ONE_PNG}" width="40" height="50" /></td>
+          <td>label</td>
+        </tr>
+      </table>
+    `;
+        const tree = await renderTreeForHtml(html);
+        const boxes = collectBoxes(tree.root);
+        const img = boxes.find((b) => b.tagName === "img");
+        expect(img).toBeDefined();
+        expect(img.contentBox.height).toBeGreaterThanOrEqual(50);
+    });
+    it("two-row table with image cells renders without zero-height rows", async () => {
+        const html = `
+      <table>
+        <tr>
+          <td><img src="data:image/png;base64,${ONE_BY_ONE_PNG}" width="50" height="60" /></td>
+          <td>Row 1 text</td>
+        </tr>
+        <tr>
+          <td><img src="data:image/png;base64,${ONE_BY_ONE_PNG}" width="50" height="70" /></td>
+          <td>Row 2 text</td>
+        </tr>
+      </table>
+    `;
+        const tree = await renderTreeForHtml(html);
+        const boxes = collectBoxes(tree.root);
+        const table = boxes.find((b) => b.tagName === "table");
+        expect(table).toBeDefined();
+        // Total height must fit both image rows (60 + 70 = 130 minimum).
+        expect(table.contentBox.height).toBeGreaterThanOrEqual(130);
+    });
+});
+describe("table cell with long mixed inline content (SEI signature regression)", () => {
+    // Mirrors the SEI/ERJ signature block: a narrow image column on the left and a long
+    // paragraph with mixed inline content (text + <b> + <a>) on the right. The paragraph
+    // must wrap into several stacked lines instead of overlapping at a single position, and
+    // the table must not overflow the page width.
+    const html = `
+    <table>
+      <tr>
+        <td><img src="data:image/png;base64,${ONE_BY_ONE_PNG}" width="60" height="80" /></td>
+        <td>
+          <p style="margin:0;font-size:11px;font-family:Calibri">Documento assinado eletronicamente por <b>Carlos Eduardo Carvalho Mendes</b>, <b>Assessor</b>, em 30/05/2025, conforme horario oficial de Brasilia, com fundamento no artigo quinto do <a href="http://example.gov">Decreto numero 46.126 de 20 de outubro de 2017</a> publicado oficialmente.</p>
+        </td>
+      </tr>
+    </table>
+  `;
+    it("wraps the paragraph into multiple stacked lines (no overlap)", async () => {
+        const tree = await renderTreeForHtml(html);
+        const runs = collectRuns(tree.root).filter((r) => r.text.trim().length > 0);
+        expect(runs.length).toBeGreaterThan(1);
+        // Collect distinct baseline Y positions (lineMatrix.f). Wrapped text must occupy
+        // several different vertical positions, not a single overlapping line.
+        const ys = runs.map((r) => Math.round(r.lineMatrix.f));
+        const distinctYs = new Set(ys);
+        expect(distinctYs.size).toBeGreaterThan(2);
+        // No two runs may sit at exactly the same (x, y) origin — that is the overlap signature.
+        const origins = runs.map((r) => `${Math.round(r.lineMatrix.e)}:${Math.round(r.lineMatrix.f)}`);
+        expect(new Set(origins).size).toBe(origins.length);
+    });
+    it("does not overflow the page content width", async () => {
+        const tree = await renderTreeForHtml(html);
+        const boxes = collectBoxes(tree.root);
+        const table = boxes.find((b) => b.tagName === "table");
+        expect(table).toBeDefined();
+        // Default test page is 794px wide with 48px margins => 698px of content width.
+        expect(table.borderBox.width).toBeLessThanOrEqual(698 + 1);
+    });
+});

package/dist/tests/pdf/alignments.spec.js

@@ -1,18 +1,18 @@
 import { renderRuns } from "../helpers/render-utils.js";
 describe("PDF text alignment (non-justify)", () => {
     it("does not apply justification to left/center/right alignments", async () => {
-        const html = `
-      <div>
-        <p style="width: 260px; text-align: left;">
-          Some sample text that wraps into multiple lines for left.
-        </p>
-        <p style="width: 260px; text-align: center;">
-          Some sample text that wraps into multiple lines for center.
-        </p>
-        <p style="width: 260px; text-align: right;">
-          Some sample text that wraps into multiple lines for right.
-        </p>
-      </div>
+        const html = `
+      <div>
+        <p style="width: 260px; text-align: left;">
+          Some sample text that wraps into multiple lines for left.
+        </p>
+        <p style="width: 260px; text-align: center;">
+          Some sample text that wraps into multiple lines for center.
+        </p>
+        <p style="width: 260px; text-align: right;">
+          Some sample text that wraps into multiple lines for right.
+        </p>
+      </div>
     `;
         const runs = await renderRuns(html);
         // no positive wordSpacing anywhere

package/dist/tests/pdf/clip-path.spec.js

@@ -39,7 +39,7 @@ describe("clip-path rendering", () => {
             },
             background: { color: { r: 0.2, g: 0.6, b: 0.9, a: 1 } },
             opacity: 1,
-            overflow: Overflow.Visible,
+            overflow: Overflow.Visible, overflowX: Overflow.Visible, overflowY: Overflow.Visible,
             textRuns: [],
             decorations: {},
             textShadows: [],
@@ -69,6 +69,8 @@ describe("clip-path rendering", () => {
         const clipPath = div.clipPath;
         expect(clipPath).toBeDefined();
         expect(clipPath?.type).toBe("polygon");
+        if (clipPath.type !== "polygon")
+            return;
         const points = clipPath.points;
         expect(points).toHaveLength(3);
         const [a, b, c] = points;

package/dist/tests/pdf/form-text-encoding.spec.js

@@ -47,7 +47,7 @@ describe("form text encoding", () => {
             },
             background: {},
             opacity: 1,
-            overflow: Overflow.Visible,
+            overflow: Overflow.Visible, overflowX: Overflow.Visible, overflowY: Overflow.Visible,
             textRuns: [],
             decorations: {},
             textShadows: [],

package/dist/tests/pdf/svg-stroke-dash.spec.js

@@ -7,10 +7,10 @@ import { GraphicsStateManager } from "../../src/pdf/renderers/graphics-state-man
 import { parseHTML } from "linkedom";
 describe("SVG Stroke Dash Support", () => {
     it("should render path with stroke-dasharray", async () => {
-        const { document } = parseHTML(`
-      <svg>
-        <path d="M10 10 L90 10" stroke="black" stroke-width="2" stroke-dasharray="5,5" />
-      </svg>
+        const { document } = parseHTML(`
+      <svg>
+        <path d="M10 10 L90 10" stroke="black" stroke-width="2" stroke-dasharray="5,5" />
+      </svg>
     `);
         const pathElement = document.querySelector("path");
         const context = { warn: () => { } };
@@ -36,10 +36,10 @@ describe("SVG Stroke Dash Support", () => {
         expect(commands).toContain("[3.75 3.75] 0 d");
     });
     it("should render path with stroke-dasharray and stroke-dashoffset", async () => {
-        const { document } = parseHTML(`
-      <svg>
-        <path d="M10 30 L90 30" stroke="black" stroke-width="2" stroke-dasharray="10 5" stroke-dashoffset="5" />
-      </svg>
+        const { document } = parseHTML(`
+      <svg>
+        <path d="M10 30 L90 30" stroke="black" stroke-width="2" stroke-dasharray="10 5" stroke-dashoffset="5" />
+      </svg>
     `);
         const pathElement = document.querySelector("path");
         const context = { warn: () => { } };

package/dist/tests/pdf/text-transform-matrix.spec.js

@@ -1,4 +1,4 @@
-import { renderRuns, renderTreeForHtml, collectBoxes, collectRuns } from "../helpers/render-utils.js";
+import { renderTreeForHtml, collectBoxes, collectRuns } from "../helpers/render-utils.js";
 const TAN_20 = Math.tan((20 * Math.PI) / 180);
 describe("PDF text transforms", () => {
     it("applies skewX to text runs (keeps linear components in CSS space)", async () => {

package/dist/tests/pdf/xref-integrity.spec.js

@@ -82,7 +82,7 @@ describe("xref table integrity", () => {
         const streamData = new Uint8Array([0x48, 0x65, 0x6c, 0x6c, 0x6f]);
         const streamRef = doc.registerStream(streamData);
         const patternRef = doc.registerPattern("P0", "<< /PatternType 2 /Shading null >>");
-        const customRef = doc.register({ Type: "/Custom", Value: 42 });
+        doc.register({ Type: "/Custom", Value: 42 });
         const fontRef = doc.registerStandardFont("Courier");
         const shadingRef = doc.registerShading("S0", "<< /ShadingType 2 /ColorSpace /DeviceRGB /Coords [0 0 1 1] /Function null >>");
         doc.addPage({

package/dist/tests/verify-subset-multi.spec.js

@@ -5,20 +5,20 @@ import fs from 'node:fs';
 describe('Multi-Font Subsetting Verification', () => {
     it('should generate a small PDF with Tinos and Arimo fonts', async () => {
         process.env.PAGYRA_FONTS_DIR = path.resolve(process.cwd(), 'assets/fonts');
-        const html = `
-            <!DOCTYPE html>
-            <html>
-            <head>
-                <style>
-                    .serif { font-family: 'Tinos', serif; font-size: 24px; }
-                    .sans { font-family: 'Arimo', sans-serif; font-size: 24px; }
-                </style>
-            </head>
-            <body>
-                <div class="serif">Serif Text: Hello World with Tinos! - ação, acentuação, coração</div>
-                <div class="sans">Sans-Serif Text: Hello World with Arimo! - ação, acentuação, coração</div>
-            </body>
-            </html>
+        const html = `
+            <!DOCTYPE html>
+            <html>
+            <head>
+                <style>
+                    .serif { font-family: 'Tinos', serif; font-size: 24px; }
+                    .sans { font-family: 'Arimo', sans-serif; font-size: 24px; }
+                </style>
+            </head>
+            <body>
+                <div class="serif">Serif Text: Hello World with Tinos! - ação, acentuação, coração</div>
+                <div class="sans">Sans-Serif Text: Hello World with Arimo! - ação, acentuação, coração</div>
+            </body>
+            </html>
         `;
         const pdfBuffer = await renderHtmlToPdf({
             html,

package/dist/tests/verify-subset.spec.js

@@ -6,18 +6,18 @@ describe('Font Subsetting Verification', () => {
     it('should generate a small PDF with Tinos font', async () => {
         // Point to assets relative to CWD (project root)
         process.env.PAGYRA_FONTS_DIR = path.resolve(process.cwd(), 'assets/fonts');
-        const html = `
-            <!DOCTYPE html>
-            <html>
-            <head>
-                <style>
-                    body { font-family: 'Tinos', serif; font-size: 24px; }
-                </style>
-            </head>
-            <body>
-                Hello World with Tinos!
-            </body>
-            </html>
+        const html = `
+            <!DOCTYPE html>
+            <html>
+            <head>
+                <style>
+                    body { font-family: 'Tinos', serif; font-size: 24px; }
+                </style>
+            </head>
+            <body>
+                Hello World with Tinos!
+            </body>
+            </html>
         `;
         const pdfBuffer = await renderHtmlToPdf({
             html,