@jasy/pdf 1.0.0-alpha.2 → 1.0.0-alpha.3

package/dist/renderer/row-renderer.js

@@ -1,30 +1,15 @@
-"use strict";
-var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
-    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
-    return new (P || (P = Promise))(function (resolve, reject) {
-        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
-        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
-        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
-        step((generator = generator.apply(thisArg, _arguments || [])).next());
-    });
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.RowRenderer = void 0;
-const renderer_registry_1 = require("../utils/renderer-registry");
-class RowRenderer {
-    static render(rowElement, objectManager) {
-        return __awaiter(this, void 0, void 0, function* () {
-            const { children } = rowElement.getProps();
-            const nodes = [];
-            if (children)
-                for (const child of children) {
-                    const renderer = renderer_registry_1.RendererRegistry.getRenderer(child);
-                    if (renderer) {
-                        nodes.push(...(yield renderer(child, objectManager)));
-                    }
+import { RendererRegistry } from "../utils/renderer-registry.js";
+export class RowRenderer {
+    static async render(rowElement, objectManager) {
+        const { children } = rowElement.getProps();
+        const nodes = [];
+        if (children)
+            for (const child of children) {
+                const renderer = RendererRegistry.getRenderer(child);
+                if (renderer) {
+                    nodes.push(...(await renderer(child, objectManager)));
                 }
-            return nodes;
-        });
+            }
+        return nodes;
     }
 }
-exports.RowRenderer = RowRenderer;

package/dist/renderer/text-renderer.d.ts

@@ -1,9 +1,10 @@
-import { TextElement, TextSegment } from "../elements/text-element";
-import { FontStyle, PDFObjectManager } from "../utils/pdf-object-manager";
-import type { FontMetrics } from "../utils/font-metrics";
-import { IRNode } from "../ir/display-list";
+import { TextElement, TextSegment } from "../elements/text-element.js";
+import { FontStyle, PDFObjectManager } from "../utils/pdf-object-manager.js";
+import type { FontMetrics } from "../utils/font-metrics.js";
+import { IRNode } from "../ir/display-list.js";
+import { TextOverflow } from "../text/line-breaker.js";
 export declare class TextRenderer {
-    static calculateTextHeight(content: string | TextSegment[], fontSize: number, fontFamily: string, fontStyle: FontStyle, objectManager: FontMetrics, maxWidth: number): number;
+    static calculateTextHeight(content: string | TextSegment[], fontSize: number, fontFamily: string, fontStyle: FontStyle, objectManager: FontMetrics, maxWidth: number, maxLines?: number, overflow?: TextOverflow, lineHeight?: number): number;
     static render(textElement: TextElement, objectManager: PDFObjectManager): Promise<IRNode[]>;
     private static _buildRuns;
 }

package/dist/renderer/text-renderer.js

@@ -1,52 +1,38 @@
-"use strict";
-var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
-    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
-    return new (P || (P = Promise))(function (resolve, reject) {
-        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
-        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
-        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
-        step((generator = generator.apply(thisArg, _arguments || [])).next());
-    });
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.TextRenderer = void 0;
-const pdf_element_1 = require("../elements/pdf-element");
-const line_breaker_1 = require("../text/line-breaker");
+import { HorizontalAlignment } from "../elements/pdf-element.js";
+import { wrapStringIntoLines, breakSegmentsIntoLines, } from "../text/line-breaker.js";
 // Distance from the top of a line down to its baseline, as a fraction of the font
 // size. ~0.683 is the standard-14 ascent ratio used to seat the first baseline.
 const BASELINE_RATIO = 683 / 1000;
-class TextRenderer {
+export class TextRenderer {
     // Measuring only needs metrics, not the full object manager. (The render pass below
     // still receives the manager because it also registers fonts/images.)
-    static calculateTextHeight(content, fontSize, fontFamily, fontStyle, objectManager, maxWidth) {
-        // Plain string: one line height per wrapped line.
+    static calculateTextHeight(content, fontSize, fontFamily, fontStyle, objectManager, maxWidth, maxLines, overflow, lineHeight = 1) {
+        // Plain string: one line box (fontSize * lineHeight) per wrapped line.
         if (typeof content === "string") {
-            const lines = (0, line_breaker_1.wrapStringIntoLines)(content, fontFamily, fontSize, fontStyle, maxWidth, objectManager);
-            return lines.length * fontSize;
+            const lines = wrapStringIntoLines(content, fontFamily, fontSize, fontStyle, maxWidth, objectManager, maxLines, overflow);
+            return lines.length * fontSize * lineHeight;
         }
-        // Segments: each line contributes its own (tallest-on-line) leading.
-        const lines = (0, line_breaker_1.breakSegmentsIntoLines)(content, { fontFamily, fontSize, fontStyle }, maxWidth, objectManager);
-        return lines.reduce((total, line) => total + line.maxFontSize, 0);
+        // Segments: each line contributes its own (tallest-on-line) leading, scaled by lineHeight.
+        const lines = breakSegmentsIntoLines(content, { fontFamily, fontSize, fontStyle }, maxWidth, objectManager, maxLines, overflow);
+        return lines.reduce((total, line) => total + line.maxFontSize * lineHeight, 0);
     }
-    static render(textElement, objectManager) {
-        return __awaiter(this, void 0, void 0, function* () {
-            const { x, y, width, fontSize, color, content, fontFamily, fontStyle, textAlignment } = textElement.getProps();
-            // Component -> display list. Wrapping and positioning stay here; the backend
-            // turns each run into BT/Tf/Td/Tj/ET. The wrapping algorithm is unchanged from
-            // the original renderer - unifying it into the engine is Phase 3.
-            return TextRenderer._buildRuns(content, fontSize, fontFamily, fontStyle, objectManager, width !== null && width !== void 0 ? width : Number.NaN, textAlignment, color, x, y);
-        });
+    static async render(textElement, objectManager) {
+        const { x, y, width, fontSize, color, content, fontFamily, fontStyle, textAlignment, maxLines, overflow, lineHeight, } = textElement.getProps();
+        // Component -> display list. Wrapping and positioning stay here; the backend
+        // turns each run into BT/Tf/Td/Tj/ET. The wrapping algorithm is unchanged from
+        // the original renderer - unifying it into the engine is Phase 3.
+        return TextRenderer._buildRuns(content, fontSize, fontFamily, fontStyle, objectManager, width ?? Number.NaN, textAlignment, color, x, y, maxLines, overflow, lineHeight);
     }
     // Lay the content out into absolutely-positioned text runs. Glyph positions match
     // the previous hand-written operators exactly (verified by pixel-identical render);
     // only the output form changed from PDF strings to `TextRun`s.
-    static _buildRuns(content, fontSize, fontFamily, fontStyle, objectManager, maxWidth, textAlignment, color, initialX, yPosition) {
+    static _buildRuns(content, fontSize, fontFamily, fontStyle, objectManager, maxWidth, textAlignment, color, initialX, yPosition, maxLines, overflow, lineHeight = 1) {
         const runs = [];
         // Horizontal offset of a line of the given width under the current alignment.
         const alignmentOffset = (lineWidth) => {
-            if (textAlignment === pdf_element_1.HorizontalAlignment.center)
+            if (textAlignment === HorizontalAlignment.center)
                 return (maxWidth - lineWidth) / 2;
-            if (textAlignment === pdf_element_1.HorizontalAlignment.right)
+            if (textAlignment === HorizontalAlignment.right)
                 return maxWidth - lineWidth;
             return 0;
         };
@@ -62,16 +48,19 @@ class TextRenderer {
         };
         // --- Plain string: one run per wrapped line. ---
         if (typeof content === "string") {
-            const lines = (0, line_breaker_1.wrapStringIntoLines)(content, fontFamily, fontSize, fontStyle, maxWidth, objectManager);
-            // yPosition is the top of the text box (top-left); seat line 0's baseline below
-            // it, then step DOWN per line. The seam flips the whole thing to PDF space.
-            const baseline = yPosition + fontSize * BASELINE_RATIO;
+            const lines = wrapStringIntoLines(content, fontFamily, fontSize, fontStyle, maxWidth, objectManager, maxLines, overflow);
+            // yPosition is the top of the text box (top-left); seat line 0's baseline below it, then step
+            // DOWN by one line box (fontSize * lineHeight) per line. The lineHeight EXTRA leading is split
+            // half above / half below (CSS/Flutter "half-leading"), so the text sits centered in its line
+            // box instead of clinging to the top. At lineHeight 1 the half-leading is 0 -> byte-identical.
+            const halfLeading = (fontSize * (lineHeight - 1)) / 2;
+            const baseline = yPosition + halfLeading + fontSize * BASELINE_RATIO;
             lines.forEach((line, index) => {
                 const lineWidth = objectManager.getStringWidth(line, fontFamily, fontSize, fontStyle);
                 runs.push({
                     type: "text",
                     x: initialX + alignmentOffset(lineWidth),
-                    y: baseline + fontSize * index,
+                    y: baseline + fontSize * lineHeight * index,
                     text: line,
                     fontFamily,
                     fontStyle,
@@ -115,11 +104,13 @@ class TextRenderer {
                 overallMaxFont = size;
         }
         let lineY = yPosition + overallMaxFont * BASELINE_RATIO;
-        for (const line of (0, line_breaker_1.breakSegmentsIntoLines)(content, { fontFamily, fontSize, fontStyle }, maxWidth, objectManager)) {
-            pushLine(line, lineY);
-            lineY += line.maxFontSize;
+        for (const line of breakSegmentsIntoLines(content, { fontFamily, fontSize, fontStyle }, maxWidth, objectManager, maxLines, overflow)) {
+            // Half-leading: shift this line's baseline down by half its own extra leading, so the line
+            // sits centered in its box (CSS/Flutter). At lineHeight 1 the shift is 0 -> byte-identical.
+            const halfLeading = (line.maxFontSize * (lineHeight - 1)) / 2;
+            pushLine(line, lineY + halfLeading);
+            lineY += line.maxFontSize * lineHeight;
         }
         return runs;
     }
 }
-exports.TextRenderer = TextRenderer;

package/dist/text/line-breaker.d.ts

@@ -1,12 +1,15 @@
-import type { FontStyle } from "../utils/pdf-object-manager";
-import type { FontMetrics } from "../utils/font-metrics";
-import type { TextSegment } from "../elements/text-element";
+import type { FontStyle } from "../utils/pdf-object-manager.js";
+import type { FontMetrics } from "../utils/font-metrics.js";
+import type { TextSegment } from "../elements/text-element.js";
 /** Default font for segments that don't override it. */
 export interface SegmentDefaults {
     fontFamily: string;
     fontSize: number;
     fontStyle: FontStyle;
 }
+/** What happens to text beyond `maxLines`: `"clip"` drops it, `"ellipsis"` ends the last kept line
+ *  with an ellipsis. Mirrors Flutter's `TextOverflow`. */
+export type TextOverflow = "clip" | "ellipsis";
 /** One laid-out line of segments. `maxFontSize` is the tallest font ON THIS LINE - its
  *  leading - matching how real engines (and this lib's plain-string path) space lines. */
 export interface SegmentLine {
@@ -22,14 +25,14 @@ export interface SegmentLine {
  * rendering call this, so they can never disagree. Depends only on `FontMetrics`,
  * not the PDF byte writer - the future fragmentation pass can reuse it.
  */
-export declare function wrapStringIntoLines(text: string, fontFamily: string, fontSize: number, fontStyle: FontStyle, maxWidth: number, metrics: FontMetrics): string[];
+export declare function wrapStringIntoLines(text: string, fontFamily: string, fontSize: number, fontStyle: FontStyle, maxWidth: number, metrics: FontMetrics, maxLines?: number, overflow?: TextOverflow): string[];
 /**
  * Break styled segments into lines that fit within `maxWidth`. Same greedy
  * word-splitting as the string breaker, but each line records the tallest font on
  * THAT line as its leading (per-line, not a paragraph-global maximum). Single source
  * of truth: both height measurement and rendering call this.
  */
-export declare function breakSegmentsIntoLines(segments: TextSegment[], defaults: SegmentDefaults, maxWidth: number, metrics: FontMetrics): SegmentLine[];
+export declare function breakSegmentsIntoLines(segments: TextSegment[], defaults: SegmentDefaults, maxWidth: number, metrics: FontMetrics, maxLines?: number, overflow?: TextOverflow): SegmentLine[];
 /**
  * Inverse of `breakSegmentsIntoLines`: flatten broken lines back into a `TextSegment[]`
  * that re-wraps to exactly those lines. The wrap consumed the space at each line break,

package/dist/text/line-breaker.js

@@ -1,8 +1,6 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.wrapStringIntoLines = wrapStringIntoLines;
-exports.breakSegmentsIntoLines = breakSegmentsIntoLines;
-exports.segmentLinesToSegments = segmentLinesToSegments;
+/** Three ASCII dots, NOT the "…" glyph (U+2026): plain dots encode in every font - standard-14
+ *  (WinAnsi) and any embedded TTF - whereas U+2026 needs a glyph the font may not carry. */
+const ELLIPSIS = "...";
 /**
  * Break a plain string into lines that each fit within `maxWidth`, splitting on
  * spaces (greedy: a word stays on the current line unless it would overflow).
@@ -11,7 +9,7 @@ exports.segmentLinesToSegments = segmentLinesToSegments;
  * rendering call this, so they can never disagree. Depends only on `FontMetrics`,
  * not the PDF byte writer - the future fragmentation pass can reuse it.
  */
-function wrapStringIntoLines(text, fontFamily, fontSize, fontStyle, maxWidth, metrics) {
+export function wrapStringIntoLines(text, fontFamily, fontSize, fontStyle, maxWidth, metrics, maxLines, overflow) {
     let currentLine = "";
     let currentWidth = 0;
     const lines = [];
@@ -19,7 +17,10 @@ function wrapStringIntoLines(text, fontFamily, fontSize, fontStyle, maxWidth, me
     words.forEach((word, index) => {
         const wordWidth = metrics.getStringWidth(word, fontFamily, fontSize, fontStyle);
         const spaceWidth = metrics.getCharWidth(" ", fontSize, undefined, fontFamily, fontStyle);
-        if (currentWidth + wordWidth > maxWidth) {
+        // Break before a word that won't fit - but only once the line has content. A single word wider
+        // than maxWidth must sit on its (empty) line and overflow, not push a phantom empty line before
+        // it (which would over-count the height by a line and shift the text down at render).
+        if (currentWidth + wordWidth > maxWidth && currentLine !== "") {
             lines.push(currentLine.trim());
             currentLine = word;
             currentWidth = wordWidth;
@@ -31,7 +32,15 @@ function wrapStringIntoLines(text, fontFamily, fontSize, fontStyle, maxWidth, me
     });
     if (currentLine)
         lines.push(currentLine.trim());
-    return lines;
+    // Open-end by default; cap only when maxLines is set (the others get undefined → untouched).
+    if (maxLines == null || lines.length <= maxLines)
+        return lines;
+    const kept = lines.slice(0, maxLines);
+    if (overflow === "ellipsis") {
+        const last = kept.length - 1;
+        kept[last] = ellipsize(kept[last], fontFamily, fontSize, fontStyle, maxWidth, metrics);
+    }
+    return kept;
 }
 /**
  * Break styled segments into lines that fit within `maxWidth`. Same greedy
@@ -39,7 +48,7 @@ function wrapStringIntoLines(text, fontFamily, fontSize, fontStyle, maxWidth, me
  * THAT line as its leading (per-line, not a paragraph-global maximum). Single source
  * of truth: both height measurement and rendering call this.
  */
-function breakSegmentsIntoLines(segments, defaults, maxWidth, metrics) {
+export function breakSegmentsIntoLines(segments, defaults, maxWidth, metrics, maxLines, overflow) {
     const lines = [];
     let width = 0;
     let maxFontSize = 0; // per line: starts at 0, grows to the tallest font on the line
@@ -54,13 +63,15 @@ function breakSegmentsIntoLines(segments, defaults, maxWidth, metrics) {
         // Start this segment's piece empty; its content is filled word-by-word below. (Not
         // the original content - otherwise a segment whose FIRST word overflows would carry
         // its whole text into the line that just closed.)
-        lineSegments.push(Object.assign(Object.assign({}, segment), { fontFamily: family, content: "" }));
+        lineSegments.push({ ...segment, fontFamily: family, content: "" });
         combined = "";
         if (maxFontSize < size)
             maxFontSize = size;
         words.forEach((word, wordIndex) => {
             const wordWidth = metrics.getStringWidth(word, family, size, style);
-            if (width + wordWidth > maxWidth) {
+            // Same guard as the string path: don't open a phantom empty line for an over-wide first word -
+            // place it (overflowing) on the current empty line instead.
+            if (width + wordWidth > maxWidth && width > 0) {
                 lines.push({ segments: lineSegments, width, maxFontSize });
                 // Start the next line; its leading resets to the wrapping segment's size.
                 width = 0;
@@ -68,13 +79,13 @@ function breakSegmentsIntoLines(segments, defaults, maxWidth, metrics) {
                 lineSegments = [];
                 combined = word;
                 width += wordWidth + spaceWidth;
-                lineSegments.push(Object.assign(Object.assign({}, segment), { content: combined }));
+                lineSegments.push({ ...segment, content: combined });
             }
             else {
                 combined += wordIndex === 0 ? word : " " + word;
                 width += wordWidth + spaceWidth;
                 if (lineSegments.length === 0) {
-                    lineSegments.push(Object.assign(Object.assign({}, segment), { fontFamily: family, content: combined }));
+                    lineSegments.push({ ...segment, fontFamily: family, content: combined });
                 }
                 lineSegments[lineSegments.length - 1].content = combined;
             }
@@ -83,7 +94,13 @@ function breakSegmentsIntoLines(segments, defaults, maxWidth, metrics) {
     if (lineSegments.length > 0) {
         lines.push({ segments: lineSegments, width, maxFontSize });
     }
-    return lines;
+    // Open-end by default; cap only when maxLines is set.
+    if (maxLines == null || lines.length <= maxLines)
+        return lines;
+    const kept = lines.slice(0, maxLines);
+    if (overflow === "ellipsis")
+        ellipsizeSegmentLine(kept[kept.length - 1], defaults, maxWidth, metrics);
+    return kept;
 }
 /**
  * Inverse of `breakSegmentsIntoLines`: flatten broken lines back into a `TextSegment[]`
@@ -92,10 +109,10 @@ function breakSegmentsIntoLines(segments, defaults, maxWidth, metrics) {
  * last word of a line and the first of the next would fuse ("a b" + "c d" -> "a bc d").
  * Used by text fragmentation to rebuild the fitted/remainder halves of a split paragraph.
  */
-function segmentLinesToSegments(lines) {
+export function segmentLinesToSegments(lines) {
     const result = [];
     lines.forEach((line, lineIndex) => {
-        line.segments.forEach((segment) => result.push(Object.assign({}, segment)));
+        line.segments.forEach((segment) => result.push({ ...segment }));
         if (lineIndex < lines.length - 1) {
             const last = result[result.length - 1];
             if (last && !last.content.endsWith(" "))
@@ -104,3 +121,37 @@ function segmentLinesToSegments(lines) {
     });
     return result;
 }
+/** Appends "…" to a single line, dropping trailing words (then characters) until the line plus the
+ *  ellipsis fits `maxWidth`. Falls back to a bare "…" if not even one character fits. */
+function ellipsize(line, fontFamily, fontSize, fontStyle, maxWidth, metrics) {
+    const fits = (s) => metrics.getStringWidth(s + ELLIPSIS, fontFamily, fontSize, fontStyle) <= maxWidth;
+    if (fits(line))
+        return line + ELLIPSIS;
+    const words = line.split(" ");
+    while (words.length > 1) {
+        words.pop();
+        if (fits(words.join(" ")))
+            return words.join(" ") + ELLIPSIS;
+    }
+    let single = words[0] ?? "";
+    while (single.length > 1) {
+        single = single.slice(0, -1);
+        if (fits(single))
+            return single + ELLIPSIS;
+    }
+    return ELLIPSIS;
+}
+/** Ellipsizes the LAST segment of a truncated segment line in place (within the width left by the
+ *  segments before it) and recomputes the line width. */
+function ellipsizeSegmentLine(line, defaults, maxWidth, metrics) {
+    const segs = line.segments;
+    if (segs.length === 0)
+        return;
+    const widthOf = (seg) => metrics.getStringWidth(seg.content, seg.fontFamily || defaults.fontFamily, seg.fontSize || defaults.fontSize, seg.fontStyle || defaults.fontStyle);
+    let prefix = 0;
+    for (let i = 0; i < segs.length - 1; i++)
+        prefix += widthOf(segs[i]);
+    const last = segs[segs.length - 1];
+    last.content = ellipsize(last.content, last.fontFamily || defaults.fontFamily, last.fontSize || defaults.fontSize, last.fontStyle || defaults.fontStyle, maxWidth - prefix, metrics);
+    line.width = prefix + widthOf(last);
+}

package/dist/text/text-style.d.ts

@@ -0,0 +1,25 @@
+import { Color } from "../common/color.js";
+import { FontStyle } from "../utils/pdf-object-manager.js";
+import { HorizontalAlignment } from "../elements/pdf-element.js";
+/**
+ * The inheritable text properties - the same set CSS and Flutter cascade. A `Text` resolves each of
+ * its own (possibly unset) properties against the nearest cascaded style: explicit > inherited >
+ * built-in default. Box/layout properties (padding, border, width, ...) are deliberately NOT here -
+ * they never inherit, exactly as in CSS.
+ */
+export interface ResolvedTextStyle {
+    fontSize: number;
+    fontFamily: string;
+    fontStyle: FontStyle;
+    color: Color;
+    textAlignment: HorizontalAlignment;
+    lineHeight: number;
+}
+/**
+ * The root of the cascade: what a `Text` falls back to when neither it nor any ancestor sets a
+ * property. These MUST match the historical `Text` defaults so a document that sets nothing renders
+ * byte-for-byte as before.
+ */
+export declare const DEFAULT_TEXT_STYLE: ResolvedTextStyle;
+/** Layers a partial override onto a complete style; an unset (undefined) field keeps the base. */
+export declare function mergeTextStyle(base: ResolvedTextStyle, override?: Partial<ResolvedTextStyle>): ResolvedTextStyle;

package/dist/text/text-style.js

@@ -0,0 +1,29 @@
+import { Color } from "../common/color.js";
+import { FontStyle } from "../utils/pdf-object-manager.js";
+import { HorizontalAlignment } from "../elements/pdf-element.js";
+/**
+ * The root of the cascade: what a `Text` falls back to when neither it nor any ancestor sets a
+ * property. These MUST match the historical `Text` defaults so a document that sets nothing renders
+ * byte-for-byte as before.
+ */
+export const DEFAULT_TEXT_STYLE = {
+    fontSize: 12,
+    fontFamily: "Helvetica",
+    fontStyle: FontStyle.Normal,
+    color: new Color(0, 0, 0),
+    textAlignment: HorizontalAlignment.left,
+    lineHeight: 1,
+};
+/** Layers a partial override onto a complete style; an unset (undefined) field keeps the base. */
+export function mergeTextStyle(base, override) {
+    if (!override)
+        return base;
+    return {
+        fontSize: override.fontSize ?? base.fontSize,
+        fontFamily: override.fontFamily ?? base.fontFamily,
+        fontStyle: override.fontStyle ?? base.fontStyle,
+        color: override.color ?? base.color,
+        textAlignment: override.textAlignment ?? base.textAlignment,
+        lineHeight: override.lineHeight ?? base.lineHeight,
+    };
+}

package/dist/utils/afm-parser.js

@@ -1,12 +1,5 @@
-"use strict";
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.AFMParser = void 0;
-const fs_1 = __importDefault(require("fs"));
-const path_1 = __importDefault(require("path"));
-class AFMParser {
+import { AGL } from "../assets/font-data.js";
+export class AFMParser {
     constructor(afmData) {
         this.advanceWidths = {};
         this.kerningPairs = {};
@@ -15,9 +8,7 @@ class AFMParser {
         this.loadGlyphList();
     }
     loadGlyphList() {
-        const afmFilePath = path_1.default.resolve(__dirname, "../", "assets/agl.txt");
-        const fileContent = fs_1.default.readFileSync(afmFilePath, "utf-8");
-        const lines = fileContent.split("\n");
+        const lines = AGL.split("\n");
         for (const line of lines) {
             const parts = line.trim().split(";");
             if (parts.length >= 2) {
@@ -88,4 +79,3 @@ class AFMParser {
         return this.kerningPairs[pair] || 0;
     }
 }
-exports.AFMParser = AFMParser;

package/dist/utils/bytes.d.ts

@@ -0,0 +1,24 @@
+/**
+ * A `Uint8Array` → a latin1 (ISO-8859-1) string: each byte 0x00-0xFF maps 1:1 to the same code point.
+ * This matches `Buffer.toString("latin1")` exactly. NOTE: do NOT use `TextDecoder("latin1")` here - per
+ * the encoding spec that label is really windows-1252, which mangles 0x80-0x9F; we need a true 1:1 pass
+ * so arbitrary binary (e.g. a compressed stream) rides through unchanged. The PDF body is assembled as
+ * such a binary string and the final encoder passes 0x00-0xFF through.
+ */
+export declare function latin1FromBytes(bytes: Uint8Array): string;
+/**
+ * A latin1 (ISO-8859-1) string → a `Uint8Array`: each char's low byte. Matches `Buffer.from(str,
+ * "latin1")` / `"binary"`. Use for the binary strings the engine assembles char-by-char (CMaps, object
+ * bodies) before they become a stream.
+ */
+export declare function bytesFromLatin1(str: string): Uint8Array;
+export declare function u8(b: Uint8Array, o: number): number;
+export declare function u16(b: Uint8Array, o: number): number;
+export declare function u32(b: Uint8Array, o: number): number;
+export declare function i16(b: Uint8Array, o: number): number;
+export declare function wu16(b: Uint8Array, value: number, offset: number): void;
+export declare function wu32(b: Uint8Array, value: number, offset: number): void;
+export declare function wi16(b: Uint8Array, value: number, offset: number): void;
+export declare function writeLatin1(b: Uint8Array, str: string, offset: number): void;
+/** Concatenate Uint8Arrays into one (mirrors Buffer.concat). */
+export declare function concatBytes(parts: Uint8Array[]): Uint8Array;

package/dist/utils/bytes.js

@@ -0,0 +1,76 @@
+// Byte helpers for an isomorphic engine (Node + browser). Kept tiny + dependency-free; as the engine
+// moves off Node-only APIs, the Node `Buffer` conveniences are replaced by these.
+/**
+ * A `Uint8Array` → a latin1 (ISO-8859-1) string: each byte 0x00-0xFF maps 1:1 to the same code point.
+ * This matches `Buffer.toString("latin1")` exactly. NOTE: do NOT use `TextDecoder("latin1")` here - per
+ * the encoding spec that label is really windows-1252, which mangles 0x80-0x9F; we need a true 1:1 pass
+ * so arbitrary binary (e.g. a compressed stream) rides through unchanged. The PDF body is assembled as
+ * such a binary string and the final encoder passes 0x00-0xFF through.
+ */
+export function latin1FromBytes(bytes) {
+    let out = "";
+    const CHUNK = 0x8000; // chunk the apply() to stay under the argument-count limit on big streams
+    for (let i = 0; i < bytes.length; i += CHUNK) {
+        out += String.fromCharCode.apply(null, bytes.subarray(i, i + CHUNK));
+    }
+    return out;
+}
+/**
+ * A latin1 (ISO-8859-1) string → a `Uint8Array`: each char's low byte. Matches `Buffer.from(str,
+ * "latin1")` / `"binary"`. Use for the binary strings the engine assembles char-by-char (CMaps, object
+ * bodies) before they become a stream.
+ */
+export function bytesFromLatin1(str) {
+    const u8a = new Uint8Array(str.length);
+    for (let i = 0; i < str.length; i++)
+        u8a[i] = str.charCodeAt(i) & 0xff;
+    return u8a;
+}
+// Big-endian integer reads from a Uint8Array (TrueType + PDF are big-endian), mirroring
+// Buffer.readUInt8 / readUInt16BE / readUInt32BE / readInt16BE without needing a Buffer.
+export function u8(b, o) {
+    return b[o];
+}
+export function u16(b, o) {
+    return (b[o] << 8) | b[o + 1];
+}
+export function u32(b, o) {
+    // Multiply the top byte (a left shift by 24 would go negative in 32-bit signed math).
+    return b[o] * 0x1000000 + ((b[o + 1] << 16) | (b[o + 2] << 8) | b[o + 3]);
+}
+export function i16(b, o) {
+    const v = (b[o] << 8) | b[o + 1];
+    return v & 0x8000 ? v - 0x10000 : v;
+}
+// Big-endian integer + latin1-string writes into a Uint8Array, mirroring Buffer.writeUInt16BE /
+// writeUInt32BE / writeInt16BE / write(str, off, len, "latin1"). Arg order matches Buffer: (value, offset).
+export function wu16(b, value, offset) {
+    b[offset] = (value >>> 8) & 0xff;
+    b[offset + 1] = value & 0xff;
+}
+export function wu32(b, value, offset) {
+    b[offset] = (value >>> 24) & 0xff;
+    b[offset + 1] = (value >>> 16) & 0xff;
+    b[offset + 2] = (value >>> 8) & 0xff;
+    b[offset + 3] = value & 0xff;
+}
+export function wi16(b, value, offset) {
+    wu16(b, value & 0xffff, offset);
+}
+export function writeLatin1(b, str, offset) {
+    for (let i = 0; i < str.length; i++)
+        b[offset + i] = str.charCodeAt(i) & 0xff;
+}
+/** Concatenate Uint8Arrays into one (mirrors Buffer.concat). */
+export function concatBytes(parts) {
+    let len = 0;
+    for (const p of parts)
+        len += p.length;
+    const out = new Uint8Array(len);
+    let off = 0;
+    for (const p of parts) {
+        out.set(p, off);
+        off += p.length;
+    }
+    return out;
+}

package/dist/utils/flex-layout.d.ts

@@ -1,5 +1,5 @@
-import { PDFElement, LayoutContext } from "../elements/pdf-element";
-import { BoxConstraints, Offset, Size } from "../layout/box-constraints";
+import { PDFElement, LayoutContext } from "../elements/pdf-element.js";
+import { BoxConstraints, Offset, Size } from "../layout/box-constraints.js";
 /** Distribution of the children ALONG the stacking (main) axis when there is leftover
  *  space and no flex child to absorb it. */
 export type MainAlign = "start" | "center" | "end" | "between" | "around";