@jasy/pdf 1.0.0-alpha.1

package/dist/renderer/pdf-renderer.js

@@ -0,0 +1,92 @@
+"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.PDFRenderer = void 0;
+const pdf_document_renderer_1 = require("./pdf-document-renderer");
+const renderer_registry_1 = require("../utils/renderer-registry");
+const elements_1 = require("../elements");
+const text_renderer_1 = require("./text-renderer");
+const container_element_1 = require("../elements/container-element");
+const rectangle_element_1 = require("../elements/rectangle-element");
+const row_element_1 = require("../elements/row-element");
+const container_renderer_1 = require("./container-renderer");
+const rectangle_renderer_1 = require("./rectangle-renderer");
+const row_renderer_1 = require("./row-renderer");
+const expanded_renderer_1 = require("./expanded-renderer");
+const padding_renderer_1 = require("./padding-renderer");
+const image_renderer_1 = require("./image-renderer");
+const line_renderer_1 = require("./line-renderer");
+const repeating_header_element_1 = require("../elements/layout/repeating-header-element");
+const repeating_header_renderer_1 = require("./repeating-header-renderer");
+const deferred_element_1 = require("../elements/layout/deferred-element");
+const deferred_renderer_1 = require("./deferred-renderer");
+const box_constraints_1 = require("../layout/box-constraints");
+class PDFRenderer {
+    static render(document, objectManager) {
+        return __awaiter(this, void 0, void 0, function* () {
+            // Register all Renderer
+            renderer_registry_1.RendererRegistry.register(elements_1.TextElement, text_renderer_1.TextRenderer.render);
+            renderer_registry_1.RendererRegistry.register(container_element_1.ContainerElement, container_renderer_1.ContainerRenderer.render);
+            renderer_registry_1.RendererRegistry.register(row_element_1.RowElement, row_renderer_1.RowRenderer.render);
+            renderer_registry_1.RendererRegistry.register(rectangle_element_1.RectangleElement, rectangle_renderer_1.RectangleRenderer.render);
+            renderer_registry_1.RendererRegistry.register(elements_1.ExpandedElement, expanded_renderer_1.ExpandedRenderer.render);
+            renderer_registry_1.RendererRegistry.register(elements_1.PaddingElement, padding_renderer_1.PaddingRenderer.render);
+            renderer_registry_1.RendererRegistry.register(elements_1.ImageElement, image_renderer_1.ImageRenderer.render);
+            renderer_registry_1.RendererRegistry.register(elements_1.LineElement, line_renderer_1.LineRenderer.render);
+            renderer_registry_1.RendererRegistry.register(repeating_header_element_1.RepeatingHeaderElement, repeating_header_renderer_1.RepeatingHeaderRenderer.render);
+            renderer_registry_1.RendererRegistry.register(deferred_element_1.DeferredElement, deferred_renderer_1.DeferredRenderer.render);
+            let pdfContent = "";
+            // Header: version line + the PDF/A binary marker (the object manager owns it so its length
+            // matches the xref offset calculation).
+            pdfContent += objectManager.getHeader();
+            // Layout pass: thread the context explicitly. The seed page config is the document
+            // default; each PageElement overrides it for its own subtree.
+            const ctx = {
+                metrics: objectManager,
+                pageConfig: objectManager.getPDFConfig(),
+            };
+            document.calculateLayout(new box_constraints_1.BoxConstraints(), { x: 0, y: 0 }, ctx);
+            // Render pages and contents (the driver paginates overflowing pages).
+            yield pdf_document_renderer_1.PDFDocumentRenderer.render(document, objectManager, ctx);
+            // Add the catalog. XMP metadata (/Metadata) and embedded files (/AF + /Names/EmbeddedFiles)
+            // are added only when present; with neither, the catalog is byte-identical to before.
+            const catalogParts = [`/Type /Catalog /Pages ${objectManager.getParentObjectNumber()} 0 R`];
+            const xmp = objectManager.getXmpMetadata();
+            if (xmp) {
+                const metadataObject = objectManager.addObject(`<< /Type /Metadata /Subtype /XML /Length ${xmp.length} >>\nstream\n${xmp}\nendstream`);
+                catalogParts.push(`/Metadata ${metadataObject} 0 R`);
+            }
+            const outputIntent = objectManager.getOutputIntent();
+            if (outputIntent) {
+                catalogParts.push(`/OutputIntents [${outputIntent} 0 R]`);
+            }
+            const attachments = objectManager.getAttachments();
+            if (attachments.length > 0) {
+                const names = attachments.map((a) => `(${a.name}) ${a.filespec} 0 R`).join(" ");
+                const af = attachments.map((a) => `${a.filespec} 0 R`).join(" ");
+                catalogParts.push(`/AF [${af}]`, `/Names << /EmbeddedFiles << /Names [${names}] >> >>`);
+            }
+            const catalogObject = `<< ${catalogParts.join(" ")} >>`;
+            objectManager.addObject(catalogObject);
+            // Now that the render pass has revealed which glyphs each embedded font uses, fill the reserved
+            // font objects with the subset font program (must happen before the objects are serialized).
+            objectManager.finalizeCustomFonts();
+            // Add rendered objects
+            pdfContent += objectManager.getRenderedObjects();
+            // Add XRef table and trailer
+            const startxref = pdfContent.length;
+            pdfContent += objectManager.getXRefTable();
+            pdfContent += objectManager.getTrailerAndXRef(startxref);
+            return pdfContent;
+        });
+    }
+}
+exports.PDFRenderer = PDFRenderer;

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

@@ -0,0 +1,8 @@
+import { PDFObjectManager } from "../utils/pdf-object-manager";
+import { RectangleElement } from "../elements/rectangle-element";
+import { IRNode } from "../ir/display-list";
+export declare class RectangleRenderer {
+    static render(rectangleElement: RectangleElement, objectManager: PDFObjectManager): Promise<IRNode[]>;
+    /** One `line` node per present side, along the box edges (top-left coordinates). */
+    private static sideLines;
+}

package/dist/renderer/rectangle-renderer.js

@@ -0,0 +1,61 @@
+"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.RectangleRenderer = void 0;
+const renderer_registry_1 = require("../utils/renderer-registry");
+class RectangleRenderer {
+    static render(rectangleElement, objectManager) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const { x, y, width, height, children, color, backgroundColor, borderWidth, radius, sideBorders, } = rectangleElement.getProps();
+            const h = height;
+            const nodes = [];
+            if (sideBorders) {
+                // Per-side borders: a fill-only box (no stroke), then a line per present side
+                // (sharp corners). This is what lets cells draw grid lines.
+                if (backgroundColor) {
+                    nodes.push({ type: "rect", x, y, width, height: h, strokeWidth: 0, fill: backgroundColor });
+                }
+                nodes.push(...RectangleRenderer.sideLines(x, y, width, h, borderWidth, sideBorders));
+            }
+            else {
+                // The box itself becomes a display-list primitive. A background means a filled box;
+                // otherwise it is stroked only. (Unchanged path - byte-identical.)
+                const node = Object.assign(Object.assign({ type: "rect", x,
+                    y,
+                    width, height: h, stroke: color, strokeWidth: borderWidth }, (backgroundColor ? { fill: backgroundColor } : {})), (radius ? { radius } : {}));
+                nodes.push(node);
+            }
+            // Children follow the box (Rectangle is also a container).
+            if (children)
+                for (const child of children) {
+                    const renderer = renderer_registry_1.RendererRegistry.getRenderer(child);
+                    if (renderer) {
+                        nodes.push(...(yield renderer(child, objectManager)));
+                    }
+                }
+            return nodes;
+        });
+    }
+    /** One `line` node per present side, along the box edges (top-left coordinates). */
+    static sideLines(x, y, width, height, strokeWidth, sides) {
+        const lines = [];
+        const add = (x1, y1, x2, y2, stroke) => {
+            if (stroke)
+                lines.push({ type: "line", x1, y1, x2, y2, stroke, strokeWidth });
+        };
+        add(x, y, x + width, y, sides.top); // top
+        add(x, y + height, x + width, y + height, sides.bottom); // bottom
+        add(x, y, x, y + height, sides.left); // left
+        add(x + width, y, x + width, y + height, sides.right); // right
+        return lines;
+    }
+}
+exports.RectangleRenderer = RectangleRenderer;

package/dist/renderer/repeating-header-renderer.d.ts

@@ -0,0 +1,6 @@
+import { PDFObjectManager } from "../utils/pdf-object-manager";
+import { RepeatingHeaderElement } from "../elements/layout/repeating-header-element";
+import { IRNode } from "../ir/display-list";
+export declare class RepeatingHeaderRenderer {
+    static render(element: RepeatingHeaderElement, objectManager: PDFObjectManager): Promise<IRNode[]>;
+}

package/dist/renderer/repeating-header-renderer.js

@@ -0,0 +1,28 @@
+"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.RepeatingHeaderRenderer = void 0;
+const renderer_registry_1 = require("../utils/renderer-registry");
+class RepeatingHeaderRenderer {
+    static render(element, objectManager) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const { header, body } = element.getProps();
+            const nodes = [];
+            for (const child of [header, body]) {
+                const renderer = renderer_registry_1.RendererRegistry.getRenderer(child);
+                if (renderer)
+                    nodes.push(...(yield renderer(child, objectManager)));
+            }
+            return nodes;
+        });
+    }
+}
+exports.RepeatingHeaderRenderer = RepeatingHeaderRenderer;

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

@@ -0,0 +1,6 @@
+import { PDFObjectManager } from "../utils/pdf-object-manager";
+import { RowElement } from "../elements/row-element";
+import { IRNode } from "../ir/display-list";
+export declare class RowRenderer {
+    static render(rowElement: RowElement, objectManager: PDFObjectManager): Promise<IRNode[]>;
+}

package/dist/renderer/row-renderer.js

@@ -0,0 +1,30 @@
+"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)));
+                    }
+                }
+            return nodes;
+        });
+    }
+}
+exports.RowRenderer = RowRenderer;

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

@@ -0,0 +1,9 @@
+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";
+export declare class TextRenderer {
+    static calculateTextHeight(content: string | TextSegment[], fontSize: number, fontFamily: string, fontStyle: FontStyle, objectManager: FontMetrics, maxWidth: number): number;
+    static render(textElement: TextElement, objectManager: PDFObjectManager): Promise<IRNode[]>;
+    private static _buildRuns;
+}

package/dist/renderer/text-renderer.js

@@ -0,0 +1,125 @@
+"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");
+// 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 {
+    // 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.
+        if (typeof content === "string") {
+            const lines = (0, line_breaker_1.wrapStringIntoLines)(content, fontFamily, fontSize, fontStyle, maxWidth, objectManager);
+            return lines.length * fontSize;
+        }
+        // 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);
+    }
+    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);
+        });
+    }
+    // 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) {
+        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)
+                return (maxWidth - lineWidth) / 2;
+            if (textAlignment === pdf_element_1.HorizontalAlignment.right)
+                return maxWidth - lineWidth;
+            return 0;
+        };
+        // Advance width WITHOUT kerning. This is how Tj moves the text cursor, so
+        // segments flowing after each other land here. (Standard-14 fonts carry no
+        // /Widths array; the viewer advances by the AFM widths - same source as below.)
+        const advanceNoKerning = (text, family, size, style) => {
+            let width = 0;
+            for (const ch of text) {
+                width += objectManager.getCharWidth(ch, size, undefined, family, style);
+            }
+            return width;
+        };
+        // --- 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;
+            lines.forEach((line, index) => {
+                const lineWidth = objectManager.getStringWidth(line, fontFamily, fontSize, fontStyle);
+                runs.push({
+                    type: "text",
+                    x: initialX + alignmentOffset(lineWidth),
+                    y: baseline + fontSize * index,
+                    text: line,
+                    fontFamily,
+                    fontStyle,
+                    fontSize,
+                    color,
+                });
+            });
+            return runs;
+        }
+        // --- Segments: break into lines (shared breaker), then emit one run per segment.
+        // Segment 0 starts at the aligned line origin; each following segment is offset by
+        // the previous segment's kerning-free advance. Each line drops by its OWN leading
+        // (tallest font on that line), so mixed-font lines space correctly and the drawn
+        // height matches the measured height.
+        const pushLine = (line, lineY) => {
+            let x = initialX + alignmentOffset(line.width);
+            line.segments.forEach((segment) => {
+                const family = segment.fontFamily || fontFamily;
+                const size = segment.fontSize || fontSize;
+                const style = segment.fontStyle || fontStyle;
+                runs.push({
+                    type: "text",
+                    x,
+                    y: lineY,
+                    text: segment.content,
+                    fontFamily: family,
+                    fontStyle: style,
+                    fontSize: size,
+                    color: segment.fontColor || color,
+                });
+                x += advanceNoKerning(segment.content, family, size, style);
+            });
+        };
+        // The overall tallest font seats the first baseline; each line then steps DOWN by
+        // its own leading. yPosition is the top of the text box (top-left); the seam flips
+        // the whole thing to PDF space.
+        let overallMaxFont = fontSize;
+        for (const segment of content) {
+            const size = segment.fontSize || fontSize;
+            if (size > overallMaxFont)
+                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;
+        }
+        return runs;
+    }
+}
+exports.TextRenderer = TextRenderer;

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

@@ -0,0 +1,40 @@
+import type { FontStyle } from "../utils/pdf-object-manager";
+import type { FontMetrics } from "../utils/font-metrics";
+import type { TextSegment } from "../elements/text-element";
+/** Default font for segments that don't override it. */
+export interface SegmentDefaults {
+    fontFamily: string;
+    fontSize: number;
+    fontStyle: FontStyle;
+}
+/** 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 {
+    segments: TextSegment[];
+    width: number;
+    maxFontSize: number;
+}
+/**
+ * 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).
+ *
+ * Single source of truth for plain-string wrapping: both height measurement and
+ * 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[];
+/**
+ * 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[];
+/**
+ * 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,
+ * so re-insert one between lines (unless the piece already ends with one) - otherwise the
+ * 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.
+ */
+export declare function segmentLinesToSegments(lines: SegmentLine[]): TextSegment[];

package/dist/text/line-breaker.js

@@ -0,0 +1,106 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.wrapStringIntoLines = wrapStringIntoLines;
+exports.breakSegmentsIntoLines = breakSegmentsIntoLines;
+exports.segmentLinesToSegments = segmentLinesToSegments;
+/**
+ * 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).
+ *
+ * Single source of truth for plain-string wrapping: both height measurement and
+ * 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) {
+    let currentLine = "";
+    let currentWidth = 0;
+    const lines = [];
+    const words = text.split(" ");
+    words.forEach((word, index) => {
+        const wordWidth = metrics.getStringWidth(word, fontFamily, fontSize, fontStyle);
+        const spaceWidth = metrics.getCharWidth(" ", fontSize, undefined, fontFamily, fontStyle);
+        if (currentWidth + wordWidth > maxWidth) {
+            lines.push(currentLine.trim());
+            currentLine = word;
+            currentWidth = wordWidth;
+        }
+        else {
+            currentLine += index === 0 ? word : " " + word;
+            currentWidth += wordWidth + spaceWidth;
+        }
+    });
+    if (currentLine)
+        lines.push(currentLine.trim());
+    return lines;
+}
+/**
+ * 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.
+ */
+function breakSegmentsIntoLines(segments, defaults, maxWidth, metrics) {
+    const lines = [];
+    let width = 0;
+    let maxFontSize = 0; // per line: starts at 0, grows to the tallest font on the line
+    let lineSegments = [];
+    let combined = "";
+    segments.forEach((segment) => {
+        const family = segment.fontFamily || defaults.fontFamily;
+        const size = segment.fontSize || defaults.fontSize;
+        const style = segment.fontStyle || defaults.fontStyle;
+        const spaceWidth = metrics.getCharWidth(" ", size, undefined, family, style);
+        const words = segment.content.split(" ");
+        // 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: "" }));
+        combined = "";
+        if (maxFontSize < size)
+            maxFontSize = size;
+        words.forEach((word, wordIndex) => {
+            const wordWidth = metrics.getStringWidth(word, family, size, style);
+            if (width + wordWidth > maxWidth) {
+                lines.push({ segments: lineSegments, width, maxFontSize });
+                // Start the next line; its leading resets to the wrapping segment's size.
+                width = 0;
+                maxFontSize = size;
+                lineSegments = [];
+                combined = word;
+                width += wordWidth + spaceWidth;
+                lineSegments.push(Object.assign(Object.assign({}, 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[lineSegments.length - 1].content = combined;
+            }
+        });
+    });
+    if (lineSegments.length > 0) {
+        lines.push({ segments: lineSegments, width, maxFontSize });
+    }
+    return lines;
+}
+/**
+ * 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,
+ * so re-insert one between lines (unless the piece already ends with one) - otherwise the
+ * 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) {
+    const result = [];
+    lines.forEach((line, lineIndex) => {
+        line.segments.forEach((segment) => result.push(Object.assign({}, segment)));
+        if (lineIndex < lines.length - 1) {
+            const last = result[result.length - 1];
+            if (last && !last.content.endsWith(" "))
+                last.content += " ";
+        }
+    });
+    return result;
+}

package/dist/utils/afm-parser.d.ts

@@ -0,0 +1,12 @@
+export declare class AFMParser {
+    private advanceWidths;
+    private kerningPairs;
+    private glyphMap;
+    constructor(afmData: string);
+    private loadGlyphList;
+    private getGlyphName;
+    private parseAFMData;
+    private parseCharMetrics;
+    getAdvanceWidth(charName: string): number;
+    getKerning(firstChar: string, secondChar: string): number;
+}

package/dist/utils/afm-parser.js

@@ -0,0 +1,91 @@
+"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 {
+    constructor(afmData) {
+        this.advanceWidths = {};
+        this.kerningPairs = {};
+        this.glyphMap = {};
+        this.parseAFMData(afmData);
+        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");
+        for (const line of lines) {
+            const parts = line.trim().split(";");
+            if (parts.length >= 2) {
+                const unicodeHex = parts[0];
+                const glyphName = parts[1];
+                // Converts the Unicode hex code into the corresponding character
+                const unicodeChar = String.fromCharCode(parseInt(unicodeHex, 16));
+                // Adds the character as the key and the glyph name as the value in the list
+                this.glyphMap[unicodeChar] = glyphName;
+            }
+        }
+    }
+    getGlyphName(char) {
+        return this.glyphMap[char] || char;
+    }
+    parseAFMData(afmData) {
+        const lines = afmData.split("\n");
+        let inCharMetrics = false;
+        for (let line of lines) {
+            line = line.trim();
+            if (line.startsWith("StartCharMetrics")) {
+                inCharMetrics = true;
+                continue;
+            }
+            if (line.startsWith("EndCharMetrics")) {
+                inCharMetrics = false;
+                continue;
+            }
+            if (inCharMetrics) {
+                const charData = this.parseCharMetrics(line);
+                if (charData) {
+                    const { charName, wx } = charData;
+                    this.advanceWidths[charName] = wx;
+                }
+            }
+            if (line.startsWith("KPX")) {
+                const parts = line.split(/\s+/);
+                const firstChar = parts[1];
+                const secondChar = parts[2];
+                const kerning = parseFloat(parts[3]);
+                const pair = `${firstChar}-${secondChar}`;
+                this.kerningPairs[pair] = kerning;
+            }
+        }
+    }
+    parseCharMetrics(line) {
+        const parts = line.split(";").map((part) => part.trim());
+        let charName = "";
+        let wx = 0;
+        for (const part of parts) {
+            if (part.startsWith("N ")) {
+                charName = part.split(" ")[1];
+            }
+            if (part.startsWith("WX ")) {
+                wx = parseFloat(part.split(" ")[1]);
+            }
+        }
+        if (charName && wx) {
+            return { charName, wx };
+        }
+        return null;
+    }
+    getAdvanceWidth(charName) {
+        return this.advanceWidths[this.getGlyphName(charName)] || 0;
+    }
+    getKerning(firstChar, secondChar) {
+        const pair = `${firstChar}-${secondChar}`;
+        return this.kerningPairs[pair] || 0;
+    }
+}
+exports.AFMParser = AFMParser;