@jasy/pdf 1.0.0-alpha.6 → 1.0.0-alpha.7

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

@@ -0,0 +1,50 @@
+/**
+ * Where an underline and a strikethrough sit, and how thick they are.
+ *
+ * These are GLYPH metrics, and they are deliberately NOT part of `FontVerticals` in
+ * `line-metrics.ts`, which holds LINE metrics. Confusing the two is exactly what produced ISSUE-5:
+ * the AFM's `Ascender` (the height of a `b`) was used to seat a baseline, a job that belongs to the
+ * `FontBBox`. Keep the two kinds of number in two places so they cannot be mixed up again.
+ *
+ * Every number here comes out of the font: the standard-14 AFM header, or a TrueType `post` +
+ * `OS/2` table. Nothing is invented. Verified against `google-chrome --headless --print-to-pdf` on
+ * the same font: Chrome's strikethrough centre lands on `xHeight / 2` (measured 0.260 em vs the
+ * font's 0.262), and its underline stroke with `text-decoration-thickness: from-font` is the font's
+ * `underlineThickness` (0.048 em vs 0.050). Chrome does NOT use the font's underline POSITION - it
+ * has its own offset - so we follow the font there and land within 0.02 em of it.
+ */
+/** A font's decoration metrics, as fractions of the em. */
+export interface FontDecoration {
+    /** Distance BELOW the baseline to the CENTRE of the underline stroke. Positive.
+     *  (The AFM defines it as "the distance from the baseline for centering underlining strokes";
+     *  FreeType reads TrueType's `post.underlinePosition` the same way.) */
+    underlinePosition: number;
+    /** Stroke thickness, used by both the underline and the strikethrough. */
+    underlineThickness: number;
+    /** Height of a lowercase `x` above the baseline. Sets where a strikethrough crosses. */
+    xHeight: number;
+    /** Height of a capital above the baseline. */
+    capHeight: number;
+}
+/** A decoration stroke: the y of its centre line, and how thick it is. Points, engine coords. */
+export interface DecorationStroke {
+    y: number;
+    thickness: number;
+}
+/** The underline for a run whose baseline sits at `baselineY` (engine coords, y grows down). */
+export declare function underlineStroke(decoration: FontDecoration, fontSize: number, baselineY: number): DecorationStroke;
+/**
+ * The strikethrough for a run whose baseline sits at `baselineY`. It crosses at half the x-height,
+ * which is what a browser does and what looks right: through the middle of the lowercase letters,
+ * not through the middle of the capitals.
+ */
+export declare function strikethroughStroke(decoration: FontDecoration, fontSize: number, baselineY: number): DecorationStroke;
+/**
+ * Cuts `[0, runWidth]` at every place the glyphs put ink, leaving the segments an underline should
+ * actually draw. `inkSpans` are x-intervals in points from the start of the run.
+ *
+ * This is CSS `text-decoration-skip-ink`, and it needs the real glyph outlines - so it only works
+ * for an embedded font. Segments narrower than the padding are dropped: a sliver of a line between
+ * two descenders reads as dirt, not as an underline.
+ */
+export declare function skipInkSegments(runWidth: number, inkSpans: Array<[number, number]>, thickness: number): Array<[number, number]>;

package/dist/text/text-decoration.js

@@ -0,0 +1,62 @@
+/**
+ * Where an underline and a strikethrough sit, and how thick they are.
+ *
+ * These are GLYPH metrics, and they are deliberately NOT part of `FontVerticals` in
+ * `line-metrics.ts`, which holds LINE metrics. Confusing the two is exactly what produced ISSUE-5:
+ * the AFM's `Ascender` (the height of a `b`) was used to seat a baseline, a job that belongs to the
+ * `FontBBox`. Keep the two kinds of number in two places so they cannot be mixed up again.
+ *
+ * Every number here comes out of the font: the standard-14 AFM header, or a TrueType `post` +
+ * `OS/2` table. Nothing is invented. Verified against `google-chrome --headless --print-to-pdf` on
+ * the same font: Chrome's strikethrough centre lands on `xHeight / 2` (measured 0.260 em vs the
+ * font's 0.262), and its underline stroke with `text-decoration-thickness: from-font` is the font's
+ * `underlineThickness` (0.048 em vs 0.050). Chrome does NOT use the font's underline POSITION - it
+ * has its own offset - so we follow the font there and land within 0.02 em of it.
+ */
+/** The underline for a run whose baseline sits at `baselineY` (engine coords, y grows down). */
+export function underlineStroke(decoration, fontSize, baselineY) {
+    return {
+        y: baselineY + decoration.underlinePosition * fontSize,
+        thickness: decoration.underlineThickness * fontSize,
+    };
+}
+/**
+ * The strikethrough for a run whose baseline sits at `baselineY`. It crosses at half the x-height,
+ * which is what a browser does and what looks right: through the middle of the lowercase letters,
+ * not through the middle of the capitals.
+ */
+export function strikethroughStroke(decoration, fontSize, baselineY) {
+    return {
+        y: baselineY - (decoration.xHeight / 2) * fontSize,
+        thickness: decoration.underlineThickness * fontSize,
+    };
+}
+/**
+ * Horizontal breathing room left on each side of a descender that interrupts an underline. Unlike
+ * everything else in this file this is a DESIGN choice, not a number read from the font - so it is
+ * expressed in the one quantity the font does give us, the stroke thickness.
+ */
+const SKIP_INK_PADDING = 1.0;
+/**
+ * Cuts `[0, runWidth]` at every place the glyphs put ink, leaving the segments an underline should
+ * actually draw. `inkSpans` are x-intervals in points from the start of the run.
+ *
+ * This is CSS `text-decoration-skip-ink`, and it needs the real glyph outlines - so it only works
+ * for an embedded font. Segments narrower than the padding are dropped: a sliver of a line between
+ * two descenders reads as dirt, not as an underline.
+ */
+export function skipInkSegments(runWidth, inkSpans, thickness) {
+    const pad = SKIP_INK_PADDING * thickness;
+    const segments = [];
+    let cursor = 0;
+    for (const [start, end] of inkSpans) {
+        const gapStart = Math.max(0, start - pad);
+        const gapEnd = Math.min(runWidth, end + pad);
+        if (gapStart > cursor + pad)
+            segments.push([cursor, gapStart]);
+        cursor = Math.max(cursor, gapEnd);
+    }
+    if (runWidth > cursor + pad)
+        segments.push([cursor, runWidth]);
+    return segments;
+}

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

@@ -13,12 +13,22 @@ export interface ResolvedTextStyle {
     fontStyle: FontStyle;
     color: Color;
     textAlignment: HorizontalAlignment;
-    lineHeight: number;
+    /** Multiplier of the font size. `undefined` means the font's natural line height
+     *  (`ascent + descent + lineGap`), i.e. CSS `line-height: normal`. */
+    lineHeight?: number;
+    /** Draw a line under the text, at the position and thickness the font declares. */
+    underline: boolean;
+    /** Draw a line through the text, at half its x-height. */
+    strikethrough: boolean;
+    /** Let the underline step around descenders (CSS `text-decoration-skip-ink`). Needs an EMBEDDED
+     *  font: the standard-14 outlines live in the viewer, not in the AFM. */
+    skipInk: boolean;
+    /** Extra space after every glyph, in points (CSS `letter-spacing`). Default 0. */
+    letterSpacing: 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.
+ * property.
  */
 export declare const DEFAULT_TEXT_STYLE: ResolvedTextStyle;
 /** Layers a partial override onto a complete style; an unset (undefined) field keeps the base. */

package/dist/text/text-style.js

@@ -3,8 +3,7 @@ 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.
+ * property.
  */
 export const DEFAULT_TEXT_STYLE = {
     fontSize: 12,
@@ -12,7 +11,11 @@ export const DEFAULT_TEXT_STYLE = {
     fontStyle: FontStyle.Normal,
     color: new Color(0, 0, 0),
     textAlignment: HorizontalAlignment.left,
-    lineHeight: 1,
+    lineHeight: undefined,
+    underline: false,
+    strikethrough: false,
+    skipInk: false,
+    letterSpacing: 0,
 };
 /** Layers a partial override onto a complete style; an unset (undefined) field keeps the base. */
 export function mergeTextStyle(base, override) {
@@ -25,5 +28,9 @@ export function mergeTextStyle(base, override) {
         color: override.color ?? base.color,
         textAlignment: override.textAlignment ?? base.textAlignment,
         lineHeight: override.lineHeight ?? base.lineHeight,
+        underline: override.underline ?? base.underline,
+        strikethrough: override.strikethrough ?? base.strikethrough,
+        skipInk: override.skipInk ?? base.skipInk,
+        letterSpacing: override.letterSpacing ?? base.letterSpacing,
     };
 }

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

@@ -1,12 +1,46 @@
+import type { FontVerticals } from "../text/line-metrics.js";
+import type { FontDecoration } from "../text/text-decoration.js";
 export declare class AFMParser {
     private advanceWidths;
     private kerningPairs;
     private glyphMap;
+    private bbox;
+    private cachedVerticals?;
+    private underlinePosition;
+    private underlineThickness;
+    private capHeight;
+    private xHeight;
+    private cachedDecoration?;
     constructor(afmData: string);
     private loadGlyphList;
     private getGlyphName;
     private parseAFMData;
     private parseCharMetrics;
+    /**
+     * The font's LINE metrics, as fractions of the em: how far a line box must reach above and below
+     * the baseline. Taken from the `FontBBox`.
+     *
+     * Not from the AFM's `Ascender` / `Descender` lines, and that distinction is the whole point.
+     * `Ascender 718` is a GLYPH metric - the height of `b`, `d`, `h` - and for Helvetica it happens to
+     * equal the cap height. The line-metric equivalent is TrueType's `hhea.ascent`, which is much
+     * taller because it has to clear the accented capitals: Arial declares 0.905 where its caps reach
+     * 0.716. That surplus above the caps (0.189) is about as large as the descent below the baseline
+     * (0.212), which is exactly why capitals look vertically centred in a browser.
+     *
+     * Helvetica's `FontBBox` is `-166 -225 1000 931`: 0.931 up, 0.225 down - within a hair of Arial's
+     * hhea numbers. So the bbox IS the standard-14 line metric, and there is no leftover slack to
+     * call a lineGap. (Seating the baseline at `Ascender` instead put every capital too high; see
+     * ISSUE-5.)
+     */
+    verticals(): FontVerticals;
+    /**
+     * The font's decoration metrics (underline / strikethrough), as fractions of the em.
+     *
+     * Symbol and ZapfDingbats declare no `CapHeight`/`XHeight` - they have no lowercase letters. For
+     * those the bbox top is the only height the font gives us, so the capitals reach it and a
+     * strikethrough crosses at half of that. Still read from the font, not guessed.
+     */
+    decoration(): FontDecoration;
     getAdvanceWidth(charName: string): number;
     getKerning(firstChar: string, secondChar: string): number;
 }

package/dist/utils/afm-parser.js

@@ -4,6 +4,15 @@ export class AFMParser {
         this.advanceWidths = {};
         this.kerningPairs = {};
         this.glyphMap = {};
+        // 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];
+        // Glyph metrics from the AFM header, for underline / strikethrough. All 14 standard fonts carry
+        // the underline pair; Symbol and ZapfDingbats have no CapHeight/XHeight (they have no lowercase).
+        this.underlinePosition = 0; // negative, as the AFM writes it: below the baseline
+        this.underlineThickness = 0;
+        this.capHeight = 0;
+        this.xHeight = 0;
         this.parseAFMData(afmData);
         this.loadGlyphList();
     }
@@ -45,6 +54,22 @@ export class AFMParser {
                     this.advanceWidths[charName] = wx;
                 }
             }
+            if (line.startsWith("UnderlinePosition ")) {
+                this.underlinePosition = parseFloat(line.slice(18));
+            }
+            if (line.startsWith("UnderlineThickness ")) {
+                this.underlineThickness = parseFloat(line.slice(19));
+            }
+            if (line.startsWith("CapHeight ")) {
+                this.capHeight = parseFloat(line.slice(10));
+            }
+            if (line.startsWith("XHeight ")) {
+                this.xHeight = parseFloat(line.slice(8));
+            }
+            if (line.startsWith("FontBBox ")) {
+                const [x0, y0, x1, y1] = line.slice(9).trim().split(/\s+/).map(parseFloat);
+                this.bbox = [x0, y0, x1, y1];
+            }
             if (line.startsWith("KPX")) {
                 const parts = line.split(/\s+/);
                 const firstChar = parts[1];
@@ -74,6 +99,48 @@ export class AFMParser {
         }
         return null;
     }
+    /**
+     * The font's LINE metrics, as fractions of the em: how far a line box must reach above and below
+     * the baseline. Taken from the `FontBBox`.
+     *
+     * Not from the AFM's `Ascender` / `Descender` lines, and that distinction is the whole point.
+     * `Ascender 718` is a GLYPH metric - the height of `b`, `d`, `h` - and for Helvetica it happens to
+     * equal the cap height. The line-metric equivalent is TrueType's `hhea.ascent`, which is much
+     * taller because it has to clear the accented capitals: Arial declares 0.905 where its caps reach
+     * 0.716. That surplus above the caps (0.189) is about as large as the descent below the baseline
+     * (0.212), which is exactly why capitals look vertically centred in a browser.
+     *
+     * Helvetica's `FontBBox` is `-166 -225 1000 931`: 0.931 up, 0.225 down - within a hair of Arial's
+     * hhea numbers. So the bbox IS the standard-14 line metric, and there is no leftover slack to
+     * call a lineGap. (Seating the baseline at `Ascender` instead put every capital too high; see
+     * ISSUE-5.)
+     */
+    verticals() {
+        if (this.cachedVerticals)
+            return this.cachedVerticals;
+        const [, yMin, , yMax] = this.bbox;
+        this.cachedVerticals = { ascent: yMax / 1000, descent: -yMin / 1000, lineGap: 0 };
+        return this.cachedVerticals;
+    }
+    /**
+     * The font's decoration metrics (underline / strikethrough), as fractions of the em.
+     *
+     * Symbol and ZapfDingbats declare no `CapHeight`/`XHeight` - they have no lowercase letters. For
+     * those the bbox top is the only height the font gives us, so the capitals reach it and a
+     * strikethrough crosses at half of that. Still read from the font, not guessed.
+     */
+    decoration() {
+        if (this.cachedDecoration)
+            return this.cachedDecoration;
+        const capHeight = this.capHeight || this.bbox[3];
+        this.cachedDecoration = {
+            underlinePosition: -this.underlinePosition / 1000, // AFM writes it negative (below the baseline)
+            underlineThickness: this.underlineThickness / 1000,
+            capHeight: capHeight / 1000,
+            xHeight: (this.xHeight || capHeight / 2) / 1000,
+        };
+        return this.cachedDecoration;
+    }
     getAdvanceWidth(charName) {
         return this.advanceWidths[this.getGlyphName(charName)] || 0;
     }

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

@@ -1,4 +1,6 @@
 import type { FontStyle } from "./pdf-object-manager.js";
+import type { FontVerticals } from "../text/line-metrics.js";
+import type { FontDecoration } from "../text/text-decoration.js";
 /**
  * Read-only font measurement - the slice of the object manager that the layout pass
  * needs. Keeping layout (and, later, fragmentation) behind this interface means those
@@ -9,4 +11,16 @@ import type { FontStyle } from "./pdf-object-manager.js";
 export interface FontMetrics {
     getStringWidth(text: string, fontFamily: string, fontSize: number, fontStyle: FontStyle): number;
     getCharWidth(char: string, fontSize: number, fullFontName?: string, fontName?: string, fontStyle?: FontStyle): number;
+    /** Ascent / descent / lineGap of a face, in em fractions - the vertical counterpart of the widths
+     *  above. Drives the line box and the baseline (see `text/line-metrics.ts`). */
+    getFontVerticals(fontFamily: string, fontStyle: FontStyle): FontVerticals;
+    /** Underline / strikethrough geometry of a face, in em fractions. GLYPH metrics, deliberately kept
+     *  apart from the LINE metrics above (see `text/text-decoration.ts`). */
+    getFontDecoration(fontFamily: string, fontStyle: FontStyle): FontDecoration;
+    /** 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;
+    /** 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): number[];
 }

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

@@ -2,6 +2,8 @@ import type { OverflowPolicy } from "../layout/fragmentation.js";
 import { TTFParser } from "./ttf-parser.js";
 import type { SecurityHandler } from "../crypto/security-handler.js";
 import type { Gradient } from "../ir/display-list.js";
+import type { FontVerticals } from "../text/line-metrics.js";
+import type { FontDecoration } from "../text/text-decoration.js";
 import { StructTree } from "./struct-tree.js";
 import { OutlineBuilder } from "./outline.js";
 import { DestRegistry } from "./dest-registry.js";
@@ -33,6 +35,8 @@ export declare class PDFObjectManager implements FontMetrics {
     pageFormat: [number, number];
     private afmParsers;
     private customFonts;
+    private verticalsCache;
+    private decorationCache;
     private customFontEmit;
     private attachments;
     private xmpMetadata?;
@@ -119,10 +123,32 @@ export declare class PDFObjectManager implements FontMetrics {
     private buildCIDFont;
     private buildToUnicode;
     private buildType0;
+    getFontVerticals(fontFamily: string, fontStyle: FontStyle): FontVerticals;
+    getFontDecoration(fontFamily: string, fontStyle: FontStyle): FontDecoration;
+    kerningEnabled: boolean;
+    setKerning(enabled: boolean): void;
+    /**
+     * The kerning adjustment for each adjacent code-point pair of `text`, in em/1000 (the sign the
+     * font declares: negative tightens). Length is `codePointCount - 1`. Zero at any pair next to a
+     * space - letters are never kerned against a space, which also keeps a per-word measure equal to a
+     * whole-line one (the space pairs contribute nothing either way).
+     *
+     * Standard-14 answers from the AFM `KPX` pairs. An embedded font has no kerning yet (its `kern` /
+     * `GPOS` tables are unparsed), so it returns zeros - never a wrong value, just no adjustment.
+     */
+    getKernPairs(text: string, fontFamily: string, fontStyle: FontStyle): number[];
+    /**
+     * Where the glyphs of `text` put ink inside a horizontal band, as x-intervals in POINTS measured
+     * from the start of the run. This is what an underline steps around ("skip-ink").
+     *
+     * `bandTop` / `bandBottom` are in points relative to the baseline, y UP (so both negative under
+     * it). Only an EMBEDDED font can answer: the standard-14 outlines live in the viewer, not here.
+     * Callers must check `isCustomFont` first rather than treat an empty result as "no descenders".
+     */
+    getInkSpansInBand(text: string, fontSize: number, fontFamily: string, fontStyle: FontStyle, bandTop: number, bandBottom: number, letterSpacing?: number): Array<[number, number]>;
     getStringWidth(text: string, fontFamily: string, fontSize: number, fontStyle: FontStyle): number;
     private getAVMParserByFont;
     getCharWidth(char: string, fontSize: number, fullFontName?: string, fontName?: string, fontStyle?: FontStyle): number;
-    private getKerning;
     getAllFontsRaw(): Map<string, FontIndexes>;
     getAllImagesRaw(): Map<string, number>;
     getRenderedObjects(): string;

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

@@ -4,7 +4,7 @@ import { md5, md5Hex } from "./md5.js";
 import { zlibSync } from "fflate";
 import { bytesFromLatin1, latin1FromBytes } from "./bytes.js";
 import { AFMParser } from "./afm-parser.js";
-import { TTFParser } from "./ttf-parser.js";
+import { mergeSpans, TTFParser } from "./ttf-parser.js";
 import { subsetTTF } from "./ttf-subsetter.js";
 import { getArrayBuffer } from "./utf8-to-windows1252-encoder.js";
 import { isEmojiCodePoint } from "../text/emoji-codepoints.js";
@@ -150,6 +150,10 @@ export class PDFObjectManager {
         // every lookup, and the lookups happen once per character - the string allocation alone was a third
         // of a custom-font render. `customFontEmit` below keeps the flat key: it is touched once per face.
         this.customFonts = new Map();
+        // Memoised getFontVerticals answers, family -> style -> metrics. Cleared when a font registers.
+        this.verticalsCache = new Map();
+        // Same, for getFontDecoration.
+        this.decorationCache = new Map();
         // Per-registered face: the reserved font-object numbers + the glyph ids actually used. The font
         // program is subsetted and the objects filled in by finalizeCustomFonts(), after the render pass.
         this.customFontEmit = new Map();
@@ -170,6 +174,11 @@ export class PDFObjectManager {
         // Named destinations (internal-link jump targets). Empty unless an `Anchor` was placed; then it emits
         // a /Names /Dests tree.
         this._dests = new DestRegistry();
+        // Whether to kern. Document-level: measuring (via `runAdvance`, which reads this off the metrics)
+        // and drawing (the backend emits a `TJ`) both consult it, so they can never disagree. OFF while the
+        // embedded-font path (kern/GPOS) is unbuilt - a standard-14-only kerning would set the 14 system
+        // fonts finer than a user's own font, which is worse than none. Flip to on when GPOS lands.
+        this.kerningEnabled = false;
         if (pageSize)
             this.pageFormat = pageFormats[pageSize];
         this.fillConfigWithStandardValues();
@@ -462,6 +471,8 @@ endstream`;
         if (this.fonts.hasFont(fontName, fontStyle)) {
             return this.fonts.getFont(fontName, fontStyle); // Already exists? Return it!
         }
+        this.verticalsCache.delete(fontName);
+        this.decorationCache.delete(fontName);
         const data = STANDARD_AFM[fullName];
         if (data !== undefined) {
             this.afmParsers.push({
@@ -495,6 +506,8 @@ endstream`;
         if (byStyle.has(style))
             return;
         byStyle.set(style, new TTFParser(data));
+        this.verticalsCache.delete(name); // this family now answers from the .ttf, not from an AFM
+        this.decorationCache.delete(name);
         // Emission (the PDF font objects + page resource) is DEFERRED to first use via ensureEmitted(),
         // so a registered-but-never-rendered face - e.g. a bundled family the document doesn't touch -
         // costs nothing in the output. The metrics above are still available for layout immediately.
@@ -690,24 +703,132 @@ endstream`;
         return (`<< /Type /Font /Subtype /Type0 /BaseFont /${pdfName(name)} /Encoding /Identity-H ` +
             `/DescendantFonts [${cidFont} 0 R] /ToUnicode ${toUnicode} 0 R >>`);
     }
+    // The vertical metrics of a face, in em fractions - what seats the baseline and sizes the line
+    // box (see text/line-metrics.ts). An embedded font answers from its own `hhea`; a standard-14
+    // font from its AFM header. Nothing here is guessed: both numbers come out of the font data.
+    //
+    // Asked once per LINE (not per character), but a long document has a lot of lines and the
+    // standard-14 lookup below is a linear scan, so the answer is memoised per face. Registering a
+    // font clears the cache - a name can go from standard-14 to embedded.
+    getFontVerticals(fontFamily, fontStyle) {
+        let byStyle = this.verticalsCache.get(fontFamily);
+        const hit = byStyle?.get(fontStyle);
+        if (hit)
+            return hit;
+        const ttf = this.getCustomFont(fontFamily, fontStyle);
+        const verticals = ttf
+            ? {
+                ascent: ttf.ascent / 1000,
+                descent: -ttf.descent / 1000, // hhea writes the descent negative
+                lineGap: ttf.lineGap / 1000,
+            }
+            : this.getAVMParserByFont(undefined, fontFamily, fontStyle).parser.verticals();
+        if (!byStyle) {
+            byStyle = new Map();
+            this.verticalsCache.set(fontFamily, byStyle);
+        }
+        byStyle.set(fontStyle, verticals);
+        return verticals;
+    }
+    // Underline / strikethrough geometry of a face, in em fractions. Same shape as getFontVerticals:
+    // an embedded font answers from its `post`/`OS/2` tables, a standard-14 one from its AFM header,
+    // and the answer is memoised per face because it is asked once per decorated run.
+    getFontDecoration(fontFamily, fontStyle) {
+        let byStyle = this.decorationCache.get(fontFamily);
+        const hit = byStyle?.get(fontStyle);
+        if (hit)
+            return hit;
+        const ttf = this.getCustomFont(fontFamily, fontStyle);
+        const decoration = ttf
+            ? ttf.decoration()
+            : this.getAVMParserByFont(undefined, fontFamily, fontStyle).parser.decoration();
+        if (!byStyle) {
+            byStyle = new Map();
+            this.decorationCache.set(fontFamily, byStyle);
+        }
+        byStyle.set(fontStyle, decoration);
+        return decoration;
+    }
+    setKerning(enabled) {
+        this.kerningEnabled = enabled;
+    }
+    /**
+     * The kerning adjustment for each adjacent code-point pair of `text`, in em/1000 (the sign the
+     * font declares: negative tightens). Length is `codePointCount - 1`. Zero at any pair next to a
+     * space - letters are never kerned against a space, which also keeps a per-word measure equal to a
+     * whole-line one (the space pairs contribute nothing either way).
+     *
+     * Standard-14 answers from the AFM `KPX` pairs. An embedded font has no kerning yet (its `kern` /
+     * `GPOS` tables are unparsed), so it returns zeros - never a wrong value, just no adjustment.
+     */
+    getKernPairs(text, fontFamily, fontStyle) {
+        const chars = [...text];
+        if (chars.length < 2)
+            return [];
+        const out = [];
+        // An embedded font kerns by GLYPH id (kern table / GPOS); a standard-14 one by character (AFM).
+        const ttf = this.getCustomFont(fontFamily, fontStyle);
+        const parser = ttf
+            ? undefined
+            : this.getAVMParserByFont(undefined, fontFamily, fontStyle).parser;
+        for (let i = 0; i < chars.length - 1; i++) {
+            const a = chars[i];
+            const b = chars[i + 1];
+            if (a === " " || b === " ") {
+                out.push(0);
+            }
+            else if (ttf) {
+                out.push(ttf.getKerning(ttf.getGlyphIndex(a.codePointAt(0)), ttf.getGlyphIndex(b.codePointAt(0))));
+            }
+            else {
+                out.push(parser.getKerning(a, b));
+            }
+        }
+        return out;
+    }
+    /**
+     * Where the glyphs of `text` put ink inside a horizontal band, as x-intervals in POINTS measured
+     * from the start of the run. This is what an underline steps around ("skip-ink").
+     *
+     * `bandTop` / `bandBottom` are in points relative to the baseline, y UP (so both negative under
+     * it). Only an EMBEDDED font can answer: the standard-14 outlines live in the viewer, not here.
+     * Callers must check `isCustomFont` first rather than treat an empty result as "no descenders".
+     */
+    getInkSpansInBand(text, fontSize, fontFamily, fontStyle, bandTop, bandBottom, letterSpacing = 0) {
+        const ttf = this.getCustomFont(fontFamily, fontStyle);
+        if (!ttf)
+            return [];
+        const scale = fontSize / ttf.unitsPerEm;
+        const spans = [];
+        let pen = 0;
+        for (const ch of text) {
+            const codePoint = ch.codePointAt(0);
+            if (codePoint !== undefined) {
+                for (const [x0, x1] of ttf.inkSpansInBand(codePoint, bandTop / scale, bandBottom / scale)) {
+                    spans.push([pen + x0 * scale, pen + x1 * scale]);
+                }
+            }
+            // The pen advances by the glyph AND its letter-spacing, so the ink of the next glyph lands
+            // where `Tc` actually draws it - otherwise the skipped gaps drift under the wrong letters.
+            pen += this.getCharWidth(ch, fontSize, undefined, fontFamily, fontStyle) + letterSpacing;
+        }
+        return mergeSpans(spans);
+    }
     // Returns the current width of a text, included kernings
     getStringWidth(text, fontFamily, fontSize, fontStyle) {
         let width = 0;
         // Iterate code points, not UTF-16 units: an astral char (emoji, CJK-ext) is a surrogate pair,
         // and indexing by unit would measure each half as its own (zero-width) "char". The spread splits
         // on code points; for BMP text this is one unit each, so the result is unchanged.
-        const chars = [...text];
-        for (let i = 0; i < chars.length; i++) {
-            const char = chars[i];
-            const nextChar = chars[i + 1] || null;
-            // Get signs width
-            const charWidth = this.getCharWidth(char, fontSize, undefined, fontFamily, fontStyle);
-            width += charWidth;
-            // If a next sign available calculate the kerning
-            if (nextChar) {
-                const kerning = this.getKerning(char, nextChar, undefined, fontFamily, fontStyle);
-                width += kerning * fontSize; // Kerning must be scaled with the font size
-            }
+        //
+        // NO KERNING. We write a run as a single `Tj`, and a viewer advances that by the font's plain
+        // widths - PDF never kerns on its own; a producer has to say so with a `TJ` array. Folding the
+        // AFM's kerning into the MEASUREMENT while the OUTPUT ignores it made every kerned string draw
+        // wider than its box: "AVATAR Wave" at 40pt by 19pt, "Total" at 11pt by 5.7%. Measured must equal
+        // drawn. The AFM kerning pairs stay parsed (`getKerning`) for the day we emit `TJ` - see the
+        // "real kerning" item in todo.md, which must cover embedded fonts too (`kern`/`GPOS`).
+        for (const char of text) {
+            width += this.getCharWidth(char, fontSize, undefined, fontFamily, fontStyle);
         }
         return width;
     }
@@ -767,13 +888,6 @@ endstream`;
         return (advanceWidth / 1000) * fontSize;
     }
     // Method to get the kerning, if available, between two signs
-    getKerning(char, nextChar, fullFontName, fontName, fontStyle) {
-        // TrueType kerning (the kern/GPOS tables) is not wired up yet - no kerning for custom fonts.
-        if (this.getCustomFont(fullFontName ?? fontName, fontStyle))
-            return 0;
-        const currentParser = this.getAVMParserByFont(fullFontName, fontName, fontStyle);
-        return currentParser.parser.getKerning(char, nextChar) / 1000;
-    }
     // Returns all fonts
     getAllFontsRaw() {
         return this.fonts.getAllFonts();