@jasy/pdf 1.0.0-beta.1 → 1.0.0-beta.3

package/dist/elements/text-element.d.ts

@@ -130,6 +130,14 @@ export declare class TextElement extends SizedPDFElement implements Fragmentable
     private readonly role?;
     constructor({ fontSize, content, fontFamily, fontStyle, color, textAlignment, maxLines, orphans, widows, overflow, lineHeight, underline, strikethrough, skipInk, letterSpacing, direction, fontFallback, textTransform, wordSpacing, textIndent, breakWord, hyphenate, ligatures, role, }: TextElementParams);
     private resolveStyle;
+    /**
+     * The last `display(metrics)` result, with what it depended on - recasing, coverage and the fallback
+     * split each walk the whole text, and every measure, break and draw asks again.
+     *
+     * COMPARED, not cleared in `resolveStyle`: that runs on every pass and resolves to the same values,
+     * so clearing would drop the answer exactly when it is about to be reused.
+     */
+    private displayed?;
     /** Justified lines may be squeezed to keep a word; every other alignment gets no slack. Read by the
      *  breaker in BOTH passes, or a measured line and a drawn one would disagree about where it ends. */
     /**

package/dist/elements/text-element.js

@@ -73,14 +73,37 @@ export class TextElement extends SizedPDFElement {
      * same width in most fonts).
      */
     display(metrics) {
+        const memo = this.displayed;
+        if (metrics &&
+            memo &&
+            memo.metrics === metrics &&
+            // A face registered since then changes what is drawable and how the fallback stack splits.
+            memo.epoch === (metrics.fontEpoch ?? 0) &&
+            memo.family === this.fontFamily &&
+            memo.style === this.fontStyle &&
+            memo.transform === this.textTransform &&
+            memo.fallback === this.fontFallback)
+            return memo.value;
         const cased = this.recased();
         // A SPAN may bring its own stack, so the element's being empty is not enough to skip the pass.
         const anyStack = this.fontFallback.length > 0 ||
             (typeof cased !== "string" && cased.some((seg) => (seg.fontFallback?.length ?? 0) > 0));
         if (!metrics)
             return cased;
+        const remember = (value) => {
+            this.displayed = {
+                metrics,
+                epoch: metrics.fontEpoch ?? 0,
+                family: this.fontFamily,
+                style: this.fontStyle,
+                transform: this.textTransform,
+                fallback: this.fontFallback,
+                value,
+            };
+            return value;
+        };
         if (!anyStack)
-            return this.covered(cased, metrics);
+            return remember(this.covered(cased, metrics));
         // Font fallback turns the content into spans - one per family - which every later pass already
         // knows how to handle. Nothing new downstream.
         const pieces = typeof cased === "string" ? [{ content: cased }] : cased;
@@ -93,7 +116,7 @@ export class TextElement extends SizedPDFElement {
                 for (const run of runs)
                     out.push({ ...seg, content: run.text, fontFamily: run.fontFamily });
         }
-        return this.covered(out, metrics);
+        return remember(this.covered(out, metrics));
     }
     /**
      * Drops or substitutes whatever the RESOLVED font cannot draw. Runs last, after the fallback stack

package/dist/text/advance.js

@@ -26,21 +26,95 @@ export function codePointCount(text) {
         n++;
     return n;
 }
+/**
+ * Glyph widths plus kerning, memoised per metrics object - the line breaker asks for the same run
+ * many times over.
+ *
+ * Keyed by nested maps on primitives, never a composed string key: building one allocates per call,
+ * which costs more than the lookup saves.
+ *
+ * `letterSpacing` is not in the key: it is added outside, so a spaced and an unspaced run share the
+ * width. Font size IS in it - scaling a cached em width drifts in the last bit, which is enough to
+ * move a line break. Kerning is a flag on the metrics rather than a key, so the entry records it and
+ * is thrown away when it flips; the same document can be rendered twice with different options.
+ */
+const ADVANCE_CACHE = new WeakMap();
+/**
+ * The innermost map a `RunFont` resolves to, remembered on the font object itself. The breaker builds
+ * one font per run and asks for every word with it, so without this each word walks five maps of which
+ * four hold a single entry.
+ */
+const BY_FONT = new WeakMap();
+function baseAdvance(metrics, text, font) {
+    let entry = ADVANCE_CACHE.get(metrics);
+    const epoch = metrics.fontEpoch ?? 0;
+    const kerning = metrics.kerningEnabled;
+    // A face registered since we measured makes a family name mean something else; a flipped kerning
+    // flag makes every width wrong. Either way the answers are stale.
+    if (!entry || entry.epoch !== epoch || entry.kerning !== kerning) {
+        entry = { epoch, kerning, byFamily: new Map() };
+        ADVANCE_CACHE.set(metrics, entry);
+    }
+    // Same font object as last time, and the metrics entry has not been replaced: the map is already known.
+    // Its FIELDS are compared, not just its identity: a caller that reuses one object and changes the
+    // size on it would otherwise be handed the previous size's map.
+    const known = BY_FONT.get(font);
+    if (known?.entry === entry &&
+        known.family === font.fontFamily &&
+        known.size === font.fontSize &&
+        known.style === font.fontStyle &&
+        known.ligatures === font.ligatures) {
+        const seen = known.byText.get(text);
+        if (seen !== undefined)
+            return seen;
+        return measureAndStore(metrics, text, font, known.byText);
+    }
+    let byStyle = entry.byFamily.get(font.fontFamily);
+    if (!byStyle)
+        entry.byFamily.set(font.fontFamily, (byStyle = new Map()));
+    let byLigatures = byStyle.get(font.fontStyle);
+    if (!byLigatures)
+        byStyle.set(font.fontStyle, (byLigatures = new Map()));
+    let bySize = byLigatures.get(font.ligatures);
+    if (!bySize)
+        byLigatures.set(font.ligatures, (bySize = new Map()));
+    let byText = bySize.get(font.fontSize);
+    if (!byText)
+        bySize.set(font.fontSize, (byText = new Map()));
+    BY_FONT.set(font, {
+        entry,
+        family: font.fontFamily,
+        size: font.fontSize,
+        style: font.fontStyle,
+        ligatures: font.ligatures,
+        byText,
+    });
+    const hit = byText.get(text);
+    if (hit !== undefined)
+        return hit;
+    return measureAndStore(metrics, text, font, byText);
+}
+/** The measurement itself, once a miss has found the map it belongs in. */
+function measureAndStore(metrics, text, font, byText) {
+    let advance = metrics.getStringWidth(text, font.fontFamily, font.fontSize, font.fontStyle, font.ligatures);
+    if (metrics.kerningEnabled) {
+        let units = 0;
+        for (const k of metrics.getKernPairs(text, font.fontFamily, font.fontStyle, font.ligatures))
+            units += k;
+        advance += (units / 1000) * font.fontSize; // kern units are em/1000
+    }
+    byText.set(text, advance);
+    return advance;
+}
 /** The advance of `text` in points: the plain glyph widths, plus kerning (if the document has it on),
  *  plus one `letterSpacing` per code point. */
 export function runAdvance(metrics, text, font, letterSpacing = 0) {
-    let advance = metrics.getStringWidth(text, font.fontFamily, font.fontSize, font.fontStyle, font.ligatures);
+    let advance = baseAdvance(metrics, text, font);
     if (letterSpacing !== 0) {
         // Per DRAWN glyph, which is what `Tc` applies to; only a ligature makes that differ.
         const glyphs = metrics.shapedGlyphCount?.(text, font.fontFamily, font.fontStyle, font.ligatures) ??
             codePointCount(text);
         advance += glyphs * letterSpacing;
     }
-    if (metrics.kerningEnabled) {
-        let units = 0;
-        for (const k of metrics.getKernPairs(text, font.fontFamily, font.fontStyle, font.ligatures))
-            units += k;
-        advance += (units / 1000) * font.fontSize; // kern units are em/1000
-    }
     return advance;
 }

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

@@ -1,5 +1,6 @@
 import type { FontVerticals } from "../text/line-metrics.js";
 import type { FontDecoration } from "../text/text-decoration.js";
+export declare function standardParser(fullName: string, data: string): AFMParser;
 export declare class AFMParser {
     private advanceWidths;
     private kerningPairs;
@@ -12,7 +13,6 @@ export declare class AFMParser {
     private xHeight;
     private cachedDecoration?;
     constructor(afmData: string);
-    private loadGlyphList;
     private getGlyphName;
     private parseAFMData;
     private parseCharMetrics;

package/dist/utils/afm-parser.js

@@ -1,9 +1,32 @@
 import { AGL } from "../assets/font-data.js";
+/** The Adobe Glyph List: code point -> glyph name. Constant, so it is parsed once per process and
+ *  shared by every face rather than rebuilt per `AFMParser`. */
+let sharedGlyphMap;
+function glyphList() {
+    if (sharedGlyphMap)
+        return sharedGlyphMap;
+    const map = {};
+    for (const line of AGL.split("\n")) {
+        const parts = line.trim().split(";");
+        if (parts.length >= 2)
+            map[String.fromCharCode(parseInt(parts[0], 16))] = parts[1];
+    }
+    return (sharedGlyphMap = map);
+}
+/** One parser per standard-14 face for the whole process: the AFM data is a constant and a parsed
+ *  face is read-only, so every document can share one. */
+const STANDARD_PARSERS = new Map();
+export function standardParser(fullName, data) {
+    let parser = STANDARD_PARSERS.get(fullName);
+    if (!parser)
+        STANDARD_PARSERS.set(fullName, (parser = new AFMParser(data)));
+    return parser;
+}
 export class AFMParser {
     constructor(afmData) {
         this.advanceWidths = {};
         this.kerningPairs = {};
-        this.glyphMap = {};
+        this.glyphMap = glyphList();
         // The font's bounding box in glyph space (1000 units / em), from the AFM header. This - not the
         // `Ascender` line - is what a line box is built from; see `verticals()`.
         this.bbox = [0, 0, 0, 0];
@@ -14,21 +37,6 @@ export class AFMParser {
         this.capHeight = 0;
         this.xHeight = 0;
         this.parseAFMData(afmData);
-        this.loadGlyphList();
-    }
-    loadGlyphList() {
-        const lines = AGL.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;

package/dist/utils/font-metrics.d.ts

@@ -20,6 +20,9 @@ export interface FontMetrics {
     /** Whether kerning is on for this document. `runAdvance` reads it so a measured advance matches the
      *  drawn one (the backend emits a `TJ` under the same flag). */
     readonly kerningEnabled: boolean;
+    /** Bumped whenever a face is registered, so a memoised measurement knows to drop it: the same family
+     *  name can mean a different face afterwards. Optional - leaving it out means never invalidating. */
+    readonly fontEpoch?: number;
     /** Per-adjacent-pair kerning of `text`, in em/1000 (negative tightens); length `codePoints - 1`,
      *  zero next to a space. Only meaningful when `kerningEnabled`. */
     getKernPairs(text: string, fontFamily: string, fontStyle: FontStyle, ligatures?: boolean): number[];

package/dist/utils/pdf-object-manager.d.ts

@@ -1,6 +1,7 @@
 import type { OverflowPolicy } from "../layout/fragmentation.js";
 import { TTFParser } from "./ttf-parser.js";
 import { type ShapedGlyph } from "../text/shape.js";
+export declare function featureKey(f: readonly string[]): string;
 import type { SecurityHandler } from "../crypto/security-handler.js";
 import type { Gradient } from "../ir/display-list.js";
 import type { FontVerticals } from "../text/line-metrics.js";
@@ -40,7 +41,12 @@ export declare class PDFObjectManager implements FontMetrics {
     private verticalsCache;
     private decorationCache;
     private customFontEmit;
+    /** Shaped runs, cached face -> feature set -> text. Nested, not one map under a composed key: that
+     *  key would carry the whole run's text, so every lookup would copy it into a fresh string. */
     private shapeCache;
+    /** Bumped by every font registration; `runAdvance` watches it to drop memoised widths, since a
+     *  family name can mean a different face afterwards. */
+    fontEpoch: number;
     private shapedOrigins;
     private attachments;
     private xmpMetadata?;

package/dist/utils/pdf-object-manager.js

@@ -3,7 +3,7 @@ import { STANDARD_AFM } from "../assets/font-data.js";
 import { md5, md5Hex } from "./md5.js";
 import { zlibSync } from "fflate";
 import { bytesFromLatin1, latin1FromBytes } from "./bytes.js";
-import { AFMParser } from "./afm-parser.js";
+import { standardParser } from "./afm-parser.js";
 import { mergeSpans, TTFParser } from "./ttf-parser.js";
 import { WoffError, isWoff, woffToSfnt } from "./woff.js";
 import { isWoff2 } from "./woff2.js";
@@ -13,8 +13,18 @@ import { shapeRun } from "../text/shape.js";
  *  drew for it. On by default like kerning - CSS, browsers and every other renderer do the same,
  *  and nobody should have to know the word to get text that is set properly. */
 const LATIN_FEATURES = ["liga"];
-/** What a run is shaped with. Arabic joining is unconditional; this is only the Latin part. */
-const features = (ligatures) => (ligatures ? LATIN_FEATURES : []);
+/** Stable, so `features(false)` does not allocate per call. */
+const NO_FEATURES = [];
+/** A feature set's cache key. Memoised only for the two arrays this module owns - a caller's array is
+ *  joined every time, since holding on to its key would outlive a mutation of it. */
+const OWN_FEATURE_KEYS = new Map([
+    [LATIN_FEATURES, LATIN_FEATURES.join(",")],
+    [NO_FEATURES, ""],
+]);
+export function featureKey(f) {
+    return OWN_FEATURE_KEYS.get(f) ?? f.join(",");
+}
+const features = (ligatures) => ligatures ? LATIN_FEATURES : NO_FEATURES;
 import { getArrayBuffer, isWindows1252 } from "./utf8-to-windows1252-encoder.js";
 import { isEmojiCodePoint } from "../text/emoji-codepoints.js";
 import { StructTree } from "./struct-tree.js";
@@ -171,7 +181,12 @@ export class PDFObjectManager {
         // program is subsetted and the objects filled in by finalizeCustomFonts(), after the render pass.
         this.customFontEmit = new Map();
         // Shaped runs, keyed by font + text; `null` means "asked, and there was nothing to shape".
+        /** Shaped runs, cached face -> feature set -> text. Nested, not one map under a composed key: that
+         *  key would carry the whole run's text, so every lookup would copy it into a fresh string. */
         this.shapeCache = new Map();
+        /** Bumped by every font registration; `runAdvance` watches it to drop memoised widths, since a
+         *  family name can mean a different face afterwards. */
+        this.fontEpoch = 0;
         // Per font, glyph -> the code points it stands for. A shaped glyph is often absent from the cmap (a
         // ligature) or maps back to a presentation form, so `ToUnicode` cannot come from the cmap alone.
         this.shapedOrigins = new Map();
@@ -550,6 +565,7 @@ endstream`;
     }
     // Registers a font
     registerFont(fontName, fontStyle = FontStyle.Normal, fullName = fontName) {
+        this.fontEpoch++;
         if (this.fonts.hasFont(fontName, fontStyle)) {
             return this.fonts.getFont(fontName, fontStyle); // Already exists? Return it!
         }
@@ -561,7 +577,7 @@ endstream`;
                 fontName,
                 fontStyle,
                 fullFontName: fullName,
-                parser: new AFMParser(data),
+                parser: standardParser(fullName, data),
             });
         }
         const resourceNumber = this.objects.length + 1; // New resource number
@@ -580,6 +596,7 @@ endstream`;
     // metrics and emits its PDF font objects. All variants share the family `name`; bold/italic are
     // separate .ttf files registered under the same name with a different style.
     registerCustomFont(name, data, style = FontStyle.Normal) {
+        this.fontEpoch++;
         let byStyle = this.customFonts.get(name);
         if (!byStyle) {
             byStyle = new Map();
@@ -767,13 +784,18 @@ endstream`;
         const resolved = this.resolveCustomStyle(fontFamily, fontStyle);
         if (!resolved)
             return undefined;
-        const key = `${this.customKey(fontFamily, resolved)}\u0000${features.join(",")}\u0000${text}`;
-        const cached = this.shapeCache.get(key);
+        const ttf = this.customFonts.get(fontFamily).get(resolved);
+        let byFeature = this.shapeCache.get(ttf);
+        if (!byFeature)
+            this.shapeCache.set(ttf, (byFeature = new Map()));
+        let byText = byFeature.get(featureKey(features));
+        if (!byText)
+            byFeature.set(featureKey(features), (byText = new Map()));
+        const cached = byText.get(text);
         if (cached !== undefined)
             return cached ?? undefined;
-        const ttf = this.customFonts.get(fontFamily).get(resolved);
         const shaped = shapeRun([...text].map((c) => c.codePointAt(0)), ttf, features) ?? null;
-        this.shapeCache.set(key, shaped);
+        byText.set(text, shaped);
         if (shaped) {
             // Recorded at shaping time - the only moment the glyph and its code points are known together.
             const fontKey = this.customKey(fontFamily, resolved);

package/dist/utils/utf8-to-windows1252-encoder.js

@@ -39,9 +39,11 @@ const CP1252_FROM_UNICODE = {
  * except the C1 range, which the table above fills with printable punctuation instead.
  */
 export function isWindows1252(codePoint) {
-    if (codePoint in CP1252_FROM_UNICODE)
-        return true;
-    return codePoint <= 0xff && !(codePoint >= 0x80 && codePoint <= 0x9f);
+    // Latin-1 first: every key in the table above is > 0xff, so this range can never be in it. Order
+    // matters - this runs per character of every measured string, and the object lookup is the slow half.
+    if (codePoint <= 0xff)
+        return codePoint < 0x80 || codePoint > 0x9f;
+    return codePoint in CP1252_FROM_UNICODE;
 }
 /** Encodes a JavaScript string to a Windows-1252 byte buffer (the PDF text encoding). */
 export function getArrayBuffer(data) {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@jasy/pdf",
-  "version": "1.0.0-beta.1",
+  "version": "1.0.0-beta.3",
   "description": "Declarative, component-based PDF generation in pure TypeScript - Flutter-style components, real AFM font metrics, a hand-rolled PDF writer. No headless browser, no Java.",
   "keywords": [
     "declarative",