@jasy/pdf 1.0.0-alpha.9 → 1.0.0-beta.1

package/dist/utils/flex-layout.js

@@ -205,24 +205,69 @@ export class FlexLayoutHelper {
         const shrinkers = children.filter((c) => c.flexShrink > 0 && !(c instanceof FlexiblePDFElement));
         const overflow = fixedMain + totalBasis + totalGap - mainAvail;
         if (shrinkers.length > 0 && Number.isFinite(mainAvail) && overflow > 0) {
-            const weight = (c) => c.flexShrink * axis.mainOf(fixedSize.get(c));
-            const totalWeight = shrinkers.reduce((n, c) => n + weight(c), 0);
-            if (totalWeight > 0) {
-                for (const child of shrinkers) {
-                    const natural = axis.mainOf(fixedSize.get(child));
-                    // Never below zero: when the GAPS alone outgrow the line, a proportional share asks for more
-                    // than a child has. No test can tell this clamp apart from its absence - `constrainWidth`
-                    // floors at 0 further down either way - but handing out a negative constraint is nonsense,
-                    // and the next reader should not have to work out that it happens to be harmless.
-                    const target = Math.max(0, natural - (weight(child) / totalWeight) * overflow);
-                    shrunkCap.set(child, target);
-                    // Re-measure NOW, not in pass 2: a narrower child may wrap to more lines, and the line's
-                    // cross extent is settled just below.
-                    const size = child.calculateLayout(axis.measureConstraints(crossAvail, target), axis.offsetAt(mainStart, crossOrigin), ctx);
-                    fixedMain += axis.mainOf(size) - natural;
-                    crossUsed = Math.max(crossUsed, axis.crossOf(size));
-                    fixedSize.set(child, size);
+            // Every child is floored at what it can actually hold - its `min-content` extent, which is CSS's
+            // automatic `min-width` on a flex item. Without it a badly overflowing line would grind a
+            // paragraph down to one word per line: the box gets narrow, the text gets tall, and nothing is
+            // gained. Past that floor a child overflows again, which is what a browser does too.
+            const naturalOf = (c) => axis.mainOf(fixedSize.get(c));
+            const floorOf = new Map(shrinkers.map((c) => [
+                c,
+                // Never above its natural size: the shrink pass may only take space away, never hand it out.
+                // Never below zero either - when the GAPS alone outgrow the line a proportional share asks
+                // for more than a child has, and a negative constraint is nonsense even though
+                // `constrainWidth` would floor it further down anyway.
+                Math.min(naturalOf(c), Math.max(0, c.minIntrinsicMain(axis.mainHorizontal, ctx))),
+            ]));
+            // CSS resolves this iteratively (Flexbox 9.7): a child that lands on its floor is FROZEN there
+            // and the share it could not absorb is handed to the rest. A single pass would leave that share
+            // unspent, so one unsqueezable child would keep the whole line overflowing while its neighbours
+            // still had room to give.
+            const target = new Map(shrinkers.map((c) => [c, naturalOf(c)]));
+            const frozen = new Set();
+            let flexible = [...shrinkers];
+            // What the frozen ones took off the overflow; the rest is always shared out from scratch, never
+            // from what a previous round already assigned.
+            let absorbedByFrozen = 0;
+            while (flexible.length > 0) {
+                const toAbsorb = overflow - absorbedByFrozen;
+                if (toAbsorb <= 1e-9)
+                    break;
+                const weight = (c) => c.flexShrink * naturalOf(c);
+                const totalWeight = flexible.reduce((n, c) => n + weight(c), 0);
+                if (totalWeight <= 0)
+                    break;
+                const froze = [];
+                for (const child of flexible) {
+                    const natural = naturalOf(child);
+                    const floor = floorOf.get(child);
+                    const wanted = natural - (weight(child) / totalWeight) * toAbsorb;
+                    if (wanted < floor) {
+                        target.set(child, floor);
+                        froze.push(child);
+                        absorbedByFrozen += natural - floor;
+                    }
+                    else {
+                        target.set(child, wanted);
+                    }
                 }
+                if (froze.length === 0)
+                    break;
+                for (const c of froze)
+                    frozen.add(c);
+                flexible = flexible.filter((c) => !frozen.has(c));
+            }
+            for (const child of shrinkers) {
+                const natural = naturalOf(child);
+                const capped = target.get(child);
+                if (capped >= natural)
+                    continue;
+                shrunkCap.set(child, capped);
+                // Re-measure NOW, not in pass 2: a narrower child may wrap to more lines, and the line's
+                // cross extent is settled just below.
+                const size = child.calculateLayout(axis.measureConstraints(crossAvail, capped), axis.offsetAt(mainStart, crossOrigin), ctx);
+                fixedMain += axis.mainOf(size) - natural;
+                crossUsed = Math.max(crossUsed, axis.crossOf(size));
+                fixedSize.set(child, size);
             }
         }
         const leftover = mainAvail - fixedMain - totalBasis - totalGap;
@@ -272,7 +317,11 @@ export class FlexLayoutHelper {
             const stretch = align === "stretch";
             let mainExtent;
             if (child instanceof FlexiblePDFElement) {
-                mainExtent = child.getBasis(percentBase) + (child.getFlex() / totalFlex) * remaining;
+                // `totalFlex` is 0 when every flex child asked for `flex: 0` (a pure `flexBasis` slot). The
+                // share is then 0/0 - a NaN that becomes the offset of every later sibling, which is the
+                // shape of the old Spacer bug. Such a child simply takes its basis.
+                const share = totalFlex > 0 ? (child.getFlex() / totalFlex) * remaining : 0;
+                mainExtent = child.getBasis(percentBase) + share;
                 // A flex child fills the MAIN axis, and its cross size is only known after layout - there is
                 // nothing to align against. So alignSelf is a no-op here, and that has to hold for the CROSS
                 // CONSTRAINT too: reading the per-child alignment would hand an `alignSelf: "start"` flex child

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

@@ -9,7 +9,7 @@ import type { FontDecoration } from "../text/text-decoration.js";
  * touching layout code.
  */
 export interface FontMetrics {
-    getStringWidth(text: string, fontFamily: string, fontSize: number, fontStyle: FontStyle): number;
+    getStringWidth(text: string, fontFamily: string, fontSize: number, fontStyle: FontStyle, ligatures?: boolean): 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`). */
@@ -22,10 +22,16 @@ export interface FontMetrics {
     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[];
+    getKernPairs(text: string, fontFamily: string, fontStyle: FontStyle, ligatures?: boolean): number[];
     /** Whether this family can draw the code point at all - what picks a face out of a fallback stack. */
     hasGlyph(codePoint: number, fontFamily: string, fontStyle: FontStyle): boolean;
+    /** Whether the document draws this code point as colour emoji rather than from the text font - it
+     *  is missing from that font on purpose, so glyph coverage must not touch it. */
+    rendersAsEmoji?(codePoint: number, fontFamily: string, fontStyle: FontStyle): boolean;
+    /** Told when a code point had to be removed because no font could draw it. Optional: a metrics
+     *  object used only for measuring (a test double) has nothing to report to. */
+    reportMissingGlyph?(codePoints: number[]): void;
     /** How many glyphs the run will DRAW, when a ligature made that differ from its code-point count.
      *  Absent or `undefined` means "the same", which is every Latin run. */
-    shapedGlyphCount?(text: string, fontFamily?: string, fontStyle?: FontStyle): number | undefined;
+    shapedGlyphCount?(text: string, fontFamily?: string, fontStyle?: FontStyle, ligatures?: boolean): number | undefined;
 }

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

@@ -65,6 +65,16 @@ export declare class PDFObjectManager implements FontMetrics {
     addObject(content: string): number;
     replaceObject(objectNumber: number, content: string): void;
     setCompress(on: boolean): void;
+    /**
+     * Code points no font in the document could draw, so they were removed rather than emitted as
+     * `.notdef` (which PDF/A forbids). Collected here because this object is the one thing threaded
+     * through BOTH passes; the caller gets them back with the bytes, so an application can say which
+     * character went missing instead of a server log nobody reads.
+     */
+    private readonly missingGlyphs;
+    reportMissingGlyph(codePoints: number[]): void;
+    /** The dropped code points, in the order first seen. Empty for a document that hit none. */
+    getMissingGlyphs(): number[];
     setOverflowPolicy(policy: OverflowPolicy): void;
     getOverflowPolicy(): OverflowPolicy;
     private encToken;
@@ -142,21 +152,28 @@ export declare class PDFObjectManager implements FontMetrics {
      * Used to pick a family out of a fallback stack, per code point.
      */
     hasGlyph(codePoint: number, fontFamily: string, fontStyle?: FontStyle): boolean;
+    /**
+     * Whether the document draws this code point through the colour-emoji path instead of the text
+     * font - a fallback emoji FONT, or an image source (`Document({ emoji })`). Such a code point is
+     * missing from the text font ON PURPOSE, so glyph coverage must leave it alone. Mirrors exactly
+     * what `getCharWidth` measures it as, or a dropped emoji would have been measured and not drawn.
+     */
+    rendersAsEmoji(codePoint: number, fontFamily: string, fontStyle: FontStyle): boolean;
     private colorRenders;
     getCustomFontResource(name: string, style?: FontStyle): FontIndexes | undefined;
     /** How many glyphs a run draws - its code-point count unless a ligature merged some. `letterSpacing`
      *  is per glyph (`Tc`), so this is what it multiplies. */
-    shapedGlyphCount(text: string, fontFamily?: string, fontStyle?: FontStyle): number | undefined;
+    shapedGlyphCount(text: string, fontFamily?: string, fontStyle?: FontStyle, ligatures?: boolean): number | undefined;
     /**
      * The shaped glyphs of a run, or undefined when nothing needed shaping. The ONE place shaping is
      * decided, so measuring and drawing cannot disagree. Memoised: a paragraph is measured several
      * times (layout, pagination, drawing).
      */
-    shapeText(text: string, fontFamily?: string, fontStyle?: FontStyle): ShapedGlyph[] | undefined;
+    shapeText(text: string, fontFamily?: string, fontStyle?: FontStyle, features?: readonly string[]): ShapedGlyph[] | undefined;
     /** Hex Identity-H for glyphs the producer already resolved (a shaped run), which cannot be given as
      *  text. Recording each keeps it in the subset. */
     registerGlyphs(name: string, glyphs: readonly number[], style?: FontStyle): string;
-    encodeCustomText(name: string, text: string, style?: FontStyle): string;
+    encodeCustomText(name: string, text: string, style?: FontStyle, shape?: boolean): string;
     private buildFontFile2;
     private buildFontDescriptor;
     private buildCIDFont;
@@ -175,7 +192,10 @@ export declare class PDFObjectManager implements FontMetrics {
      * 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[];
+    /** Kerning between adjacent GLYPHS - what a shaped run needs, and what the backend already holds.
+     *  Same lookup as the character path; `getKerning` is keyed by glyph id either way. */
+    getGlyphKernPairs(glyphs: readonly number[], fontFamily: string, fontStyle: FontStyle): number[];
+    getKernPairs(text: string, fontFamily: string, fontStyle: FontStyle, ligatures?: boolean): 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").
@@ -185,7 +205,7 @@ export declare class PDFObjectManager implements FontMetrics {
      * 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;
+    getStringWidth(text: string, fontFamily: string, fontSize: number, fontStyle: FontStyle, ligatures?: boolean): number;
     private getAVMParserByFont;
     getCharWidth(char: string, fontSize: number, fullFontName?: string, fontName?: string, fontStyle?: FontStyle): number;
     getAllFontsRaw(): Map<string, FontIndexes>;

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

@@ -5,9 +5,16 @@ import { zlibSync } from "fflate";
 import { bytesFromLatin1, latin1FromBytes } from "./bytes.js";
 import { AFMParser } from "./afm-parser.js";
 import { mergeSpans, TTFParser } from "./ttf-parser.js";
-import { isWoff, woffToSfnt } from "./woff.js";
+import { WoffError, isWoff, woffToSfnt } from "./woff.js";
+import { isWoff2 } from "./woff2.js";
 import { subsetTTF } from "./ttf-subsetter.js";
 import { shapeRun } from "../text/shape.js";
+/** What Latin text is shaped with unless a run says otherwise: the ligatures a font's designer
+ *  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 : []);
 import { getArrayBuffer, isWindows1252 } from "./utf8-to-windows1252-encoder.js";
 import { isEmojiCodePoint } from "../text/emoji-codepoints.js";
 import { StructTree } from "./struct-tree.js";
@@ -189,6 +196,15 @@ export class PDFObjectManager {
         // Interactive form fields (AcroForm). Empty unless a form field was placed; then finalize() emits the
         // catalog /AcroForm dict and each field's widget lands in its page /Annots.
         this._acroform = new AcroFormCollector();
+        // Overflow policy for unbreakable content taller than a page region (default "error"); the renderer
+        // seeds it into the layout-context root so packChildren can act on it.
+        /**
+         * Code points no font in the document could draw, so they were removed rather than emitted as
+         * `.notdef` (which PDF/A forbids). Collected here because this object is the one thing threaded
+         * through BOTH passes; the caller gets them back with the bytes, so an application can say which
+         * character went missing instead of a server log nobody reads.
+         */
+        this.missingGlyphs = new Set();
         // 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
@@ -216,8 +232,14 @@ export class PDFObjectManager {
     setCompress(on) {
         this.compress = on;
     }
-    // Overflow policy for unbreakable content taller than a page region (default "error"); the renderer
-    // seeds it into the layout-context root so packChildren can act on it.
+    reportMissingGlyph(codePoints) {
+        for (const cp of codePoints)
+            this.missingGlyphs.add(cp);
+    }
+    /** The dropped code points, in the order first seen. Empty for a document that hit none. */
+    getMissingGlyphs() {
+        return [...this.missingGlyphs];
+    }
     setOverflowPolicy(policy) {
         this.overflowPolicy = policy;
     }
@@ -568,6 +590,14 @@ endstream`;
         // A WOFF is the same sfnt behind a small wrapper, so it is unpacked HERE - the one place every
         // font path meets (a file, raw bytes, a URL, a browser upload) - and TTFParser never learns a
         // second container format.
+        // WOFF2 cannot be unwrapped here: its Brotli decoder is imported lazily, which makes it async,
+        // and this is a synchronous constructor path. `renderPdf` unwraps it one step earlier - so the
+        // only way to arrive here still packed is by calling the engine directly.
+        if (isWoff2(data)) {
+            throw new WoffError("a WOFF2 font reached the object manager still packed. Pass it through " +
+                "renderToBytes(doc, { fonts }) or doc.addFont(...) - unpacking WOFF2 needs Brotli, which " +
+                "is loaded asynchronously, so it happens one step earlier in renderPdf.");
+        }
         byStyle.set(style, new TTFParser(isWoff(data) ? woffToSfnt(data) : data));
         this.verticalsCache.delete(name); // this family now answers from the .ttf, not from an AFM
         this.decorationCache.delete(name);
@@ -694,6 +724,23 @@ endstream`;
             return ttf.getGlyphIndex(codePoint) !== 0;
         return isWindows1252(codePoint);
     }
+    /**
+     * Whether the document draws this code point through the colour-emoji path instead of the text
+     * font - a fallback emoji FONT, or an image source (`Document({ emoji })`). Such a code point is
+     * missing from the text font ON PURPOSE, so glyph coverage must leave it alone. Mirrors exactly
+     * what `getCharWidth` measures it as, or a dropped emoji would have been measured and not drawn.
+     */
+    rendersAsEmoji(codePoint, fontFamily, fontStyle) {
+        const ttf = this.getCustomFont(fontFamily, fontStyle);
+        if (ttf && this.colorRenders(ttf, codePoint))
+            return true;
+        if (this.emojiFontName && this.emojiFontName !== fontFamily) {
+            const emoji = this.getColorFont(this.emojiFontName, fontStyle);
+            if (emoji && this.colorRenders(emoji, codePoint))
+                return true;
+        }
+        return this.emojiImage !== undefined && isEmojiCodePoint(codePoint);
+    }
     colorRenders(ttf, codePoint) {
         return ttf.getColorGlyph(ttf.getGlyphIndex(codePoint)) !== null;
     }
@@ -708,24 +755,24 @@ endstream`;
     }
     /** How many glyphs a run draws - its code-point count unless a ligature merged some. `letterSpacing`
      *  is per glyph (`Tc`), so this is what it multiplies. */
-    shapedGlyphCount(text, fontFamily, fontStyle) {
-        return this.shapeText(text, fontFamily, fontStyle)?.length;
+    shapedGlyphCount(text, fontFamily, fontStyle, ligatures = true) {
+        return this.shapeText(text, fontFamily, fontStyle, features(ligatures))?.length;
     }
     /**
      * The shaped glyphs of a run, or undefined when nothing needed shaping. The ONE place shaping is
      * decided, so measuring and drawing cannot disagree. Memoised: a paragraph is measured several
      * times (layout, pagination, drawing).
      */
-    shapeText(text, fontFamily, fontStyle = FontStyle.Normal) {
+    shapeText(text, fontFamily, fontStyle = FontStyle.Normal, features = LATIN_FEATURES) {
         const resolved = this.resolveCustomStyle(fontFamily, fontStyle);
         if (!resolved)
             return undefined;
-        const key = `${this.customKey(fontFamily, resolved)}\u0000${text}`;
+        const key = `${this.customKey(fontFamily, resolved)}\u0000${features.join(",")}\u0000${text}`;
         const cached = this.shapeCache.get(key);
         if (cached !== undefined)
             return cached ?? undefined;
         const ttf = this.customFonts.get(fontFamily).get(resolved);
-        const shaped = shapeRun([...text].map((c) => c.codePointAt(0)), ttf) ?? null;
+        const shaped = shapeRun([...text].map((c) => c.codePointAt(0)), ttf, features) ?? null;
         this.shapeCache.set(key, shaped);
         if (shaped) {
             // Recorded at shaping time - the only moment the glyph and its code points are known together.
@@ -755,7 +802,7 @@ endstream`;
     }
     // Encodes text as a hex Identity-H string for an embedded font's Tj operator: each codepoint
     // becomes its 2-byte glyph id (CID == GID under /CIDToGIDMap /Identity).
-    encodeCustomText(name, text, style = FontStyle.Normal) {
+    encodeCustomText(name, text, style = FontStyle.Normal, shape = true) {
         const resolved = this.resolveCustomStyle(name, style);
         if (!resolved)
             return "";
@@ -765,7 +812,9 @@ endstream`;
         const { ttf, used } = emit;
         const hex4 = (gid) => gid.toString(16).padStart(4, "0").toUpperCase();
         // The SAME shaped run the measuring path used, so the glyphs drawn are the glyphs measured.
-        const shaped = this.shapeText(text, name, style);
+        // `shape: false` is for a caller that has ALREADY decided the run is unshaped - the renderer puts
+        // shaped glyphs in the IR node, so the backend's text path is the unshaped one by definition.
+        const shaped = shape ? this.shapeText(text, name, style) : undefined;
         if (shaped) {
             let out = "";
             for (const g of shaped) {
@@ -900,15 +949,30 @@ endstream`;
      * 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) {
+    /** Kerning between adjacent GLYPHS - what a shaped run needs, and what the backend already holds.
+     *  Same lookup as the character path; `getKerning` is keyed by glyph id either way. */
+    getGlyphKernPairs(glyphs, fontFamily, fontStyle) {
+        const ttf = this.getCustomFont(fontFamily, fontStyle);
+        if (!ttf)
+            return [];
+        const pairs = [];
+        for (let i = 0; i < glyphs.length - 1; i++) {
+            pairs.push(ttf.getKerning(glyphs[i], glyphs[i + 1]));
+        }
+        return pairs;
+    }
+    getKernPairs(text, fontFamily, fontStyle, ligatures = true) {
         const chars = [...text];
         if (chars.length < 2)
             return [];
-        // A shaped run does not kern here: these pairs are keyed by the UNSHAPED glyphs, and the `TJ`
-        // path would re-shape each chunk on its own, turning every letter isolated. Arabic kerning is in
-        // GPOS, applied during shaping - not built (`todo.md`).
-        if (this.shapeText(text, fontFamily, fontStyle))
-            return [];
+        // A shaped run kerns over its SHAPED glyphs, not its characters: after shaping there may be fewer
+        // glyphs than code points (a ligature), and the pairs that matter are the ones actually drawn.
+        // `getKerning` is keyed by glyph id anyway, so this is the same lookup - and the backend now emits
+        // a `TJ` over glyph chunks, which is what used to be missing. One adjustment per adjacent DRAWN
+        // pair, either path, so `runAdvance` measures exactly what is drawn.
+        const shaped = this.shapeText(text, fontFamily, fontStyle, features(ligatures));
+        if (shaped)
+            return this.getGlyphKernPairs(shaped.map((g) => g.glyph), fontFamily, fontStyle);
         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);
@@ -959,10 +1023,10 @@ endstream`;
         return mergeSpans(spans);
     }
     // Returns the current width of a text, included kernings
-    getStringWidth(text, fontFamily, fontSize, fontStyle) {
+    getStringWidth(text, fontFamily, fontSize, fontStyle, ligatures = true) {
         // Shaping first: a joined run is narrower than the same letters apart, so measuring the unshaped
         // form while drawing the shaped one would break every line. Both sides ask `shapeText`.
-        const shaped = this.shapeText(text, fontFamily, fontStyle);
+        const shaped = this.shapeText(text, fontFamily, fontStyle, features(ligatures));
         if (shaped) {
             const ttf = this.getCustomFont(fontFamily, fontStyle);
             return shaped.reduce((w, g) => w + ttf.unitsToPoints(g.advance, fontSize), 0);

package/dist/utils/renderer-registry.d.ts

@@ -1,6 +1,18 @@
+/**
+ * Thrown when an element reaches the render pass with no registered renderer.
+ *
+ * This used to return undefined and every call site skipped the element silently, so a whole document
+ * could serialize to an empty content stream and still be a valid PDF - a blank page, no warning
+ * (ISSUE-11). The registry is keyed on the CONSTRUCTOR, which makes it the one place in the engine that
+ * two loaded copies of the library break: elements built by copy A are invisible to copy B.
+ */
+export declare class MissingRendererError extends Error {
+    readonly elementName: string;
+    constructor(elementName: string);
+}
 export declare class RendererRegistry {
     private static renderers;
     static register(elementClass: Function, renderer: Function): void;
-    static getRenderer(element: object): Function | undefined;
+    static getRenderer(element: object): Function;
     static isRendererAsync(renderer: Function): boolean;
 }

package/dist/utils/renderer-registry.js

@@ -1,3 +1,20 @@
+/**
+ * Thrown when an element reaches the render pass with no registered renderer.
+ *
+ * This used to return undefined and every call site skipped the element silently, so a whole document
+ * could serialize to an empty content stream and still be a valid PDF - a blank page, no warning
+ * (ISSUE-11). The registry is keyed on the CONSTRUCTOR, which makes it the one place in the engine that
+ * two loaded copies of the library break: elements built by copy A are invisible to copy B.
+ */
+export class MissingRendererError extends Error {
+    constructor(elementName) {
+        super(`@jasy/pdf: no renderer registered for "${elementName}". Either the element was never registered ` +
+            `in PDFRenderer.render(), or two copies of @jasy/pdf are loaded - the registry is keyed on the ` +
+            `element's constructor, so elements built by one copy cannot be rendered by the other. ` +
+            `Check the dependency tree for a duplicate (e.g. \`pnpm why @jasy/pdf\`).`);
+        this.elementName = elementName;
+    }
+}
 export class RendererRegistry {
     static register(elementClass, renderer) {
         if (!RendererRegistry.renderers.has(elementClass)) {
@@ -5,8 +22,12 @@ export class RendererRegistry {
         }
     }
     // Keyed on the element's constructor, so it only needs an object - not `any`.
+    // Throws rather than returning undefined: a missing renderer is always a bug, and skipping it drew nothing.
     static getRenderer(element) {
-        return RendererRegistry.renderers.get(element.constructor);
+        const renderer = RendererRegistry.renderers.get(element.constructor);
+        if (!renderer)
+            throw new MissingRendererError(element.constructor.name);
+        return renderer;
     }
     static isRendererAsync(renderer) {
         return renderer.constructor.name === "AsyncFunction";

package/dist/utils/woff2.d.ts

@@ -0,0 +1,6 @@
+export declare const isWoff2: (bytes: Uint8Array) => boolean;
+/**
+ * The whole container: header, directory, one Brotli stream holding every table back to back, then
+ * `glyf`/`loca` put back together and the sfnt reassembled around them.
+ */
+export declare function woff2ToSfnt(woff2: Uint8Array): Promise<Uint8Array>;