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

package/dist/text/advance.js

@@ -26,21 +26,63 @@ 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();
+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);
+    }
+    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()));
+    const hit = byText.get(text);
+    if (hit !== undefined)
+        return hit;
+    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

@@ -12,7 +12,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,23 @@
 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);
+}
 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 +28,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

@@ -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!
         }
@@ -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.2",
   "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",