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

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/ttf-parser.d.ts

@@ -1,4 +1,5 @@
 import type { FontDecoration } from "../text/text-decoration.js";
+import { GsubTable } from "./gsub.js";
 export type GlyphPathCommand = {
     type: "M";
     x: number;
@@ -77,14 +78,19 @@ export declare class TTFParser {
     private kernPairs;
     private hasKerning;
     private gposPairPos;
+    private gsubTable?;
     constructor(data: Uint8Array);
     getData(): Uint8Array;
     glyphCount(): number;
     glyphWidths(): number[];
     reverseCmap(): Map<number, number>;
     private toGlyphSpace;
+    /** The font's `GSUB`, or undefined when it has none. Parsed once, on demand. */
+    gsub(): GsubTable | undefined;
     getGlyphIndex(codePoint: number): number;
     getAdvanceWidth(glyphIndex: number): number;
+    /** Font units -> points at `fontSize`; the one scaling rule for shaped and plain advances alike. */
+    unitsToPoints(units: number, fontSize: number): number;
     getCharWidth(char: string, fontSize: number): number;
     getStringWidth(text: string, fontSize: number): number;
     private readDecorationMetrics;

package/dist/utils/ttf-parser.js

@@ -2,6 +2,7 @@
 // Slice 1: glyph advance widths (hmtx) + the Unicode→glyph map (cmap), enough to compute
 // text width the same way AFMParser does for the standard-14. Embedding/subsetting come later.
 import { i16, latin1FromBytes, u8, u16, u32 } from "./bytes.js";
+import { GsubTable } from "./gsub.js";
 const IDENTITY = [1, 0, 0, 1, 0, 0];
 /** Sorts x-intervals and unions the overlapping ones. */
 export function mergeSpans(spans) {
@@ -151,6 +152,20 @@ export class TTFParser {
     toGlyphSpace(v) {
         return Math.round((v * 1000) / this.unitsPerEm);
     }
+    /** The font's `GSUB`, or undefined when it has none. Parsed once, on demand. */
+    gsub() {
+        if (this.gsubTable === undefined) {
+            const record = this.tables["GSUB"];
+            // Degrade to "no shaping" rather than break font loading - same rule as kern.
+            try {
+                this.gsubTable = record ? new GsubTable(this.data, record.offset) : null;
+            }
+            catch {
+                this.gsubTable = null;
+            }
+        }
+        return this.gsubTable ?? undefined;
+    }
     // Codepoint → glyph id (0 = .notdef when the font has no glyph for it).
     getGlyphIndex(codePoint) {
         const g = this.cmap.get(codePoint);
@@ -169,6 +184,10 @@ export class TTFParser {
         return this.advanceWidths[i] ?? 0;
     }
     // Char width at fontSize, scaled from font units (em = unitsPerEm) to points.
+    /** Font units -> points at `fontSize`; the one scaling rule for shaped and plain advances alike. */
+    unitsToPoints(units, fontSize) {
+        return (units / this.unitsPerEm) * fontSize;
+    }
     getCharWidth(char, fontSize) {
         const units = this.getAdvanceWidth(this.getGlyphIndex(char.codePointAt(0)));
         return (units / this.unitsPerEm) * fontSize;

package/dist/utils/utf8-to-windows1252-encoder.d.ts

@@ -1,2 +1,8 @@
+/**
+ * Whether Windows-1252 can carry this code point - which is exactly what a standard-14 font can draw,
+ * since that is the encoding its `/Widths` array is indexed by. Latin-1 passes straight through,
+ * except the C1 range, which the table above fills with printable punctuation instead.
+ */
+export declare function isWindows1252(codePoint: number): boolean;
 /** Encodes a JavaScript string to a Windows-1252 byte buffer (the PDF text encoding). */
 export declare function getArrayBuffer(data: string): ArrayBuffer;

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

@@ -33,6 +33,16 @@ const CP1252_FROM_UNICODE = {
     0x017e: 0x9e, // ž z caron
     0x0178: 0x9f, // Ÿ Y diaeresis
 };
+/**
+ * Whether Windows-1252 can carry this code point - which is exactly what a standard-14 font can draw,
+ * since that is the encoding its `/Widths` array is indexed by. Latin-1 passes straight through,
+ * 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);
+}
 /** Encodes a JavaScript string to a Windows-1252 byte buffer (the PDF text encoding). */
 export function getArrayBuffer(data) {
     const u8 = new Uint8Array(data.length);

package/dist/utils/woff.d.ts

@@ -0,0 +1,10 @@
+export declare class WoffError extends Error {
+    constructor(message: string);
+}
+/** Whether these bytes are a WOFF 1.0 container. Cheap enough to call on every font. */
+export declare const isWoff: (bytes: Uint8Array) => boolean;
+/**
+ * Unpack a WOFF into the sfnt it wraps. The result is byte-for-byte what a `.ttf` of the same font
+ * would be, apart from table padding, so nothing downstream can tell the difference.
+ */
+export declare function woffToSfnt(woff: Uint8Array): Uint8Array;

package/dist/utils/woff.js

@@ -0,0 +1,116 @@
+import { inflateBounded } from "./inflate.js";
+/**
+ * WOFF 1.0 -> plain sfnt, so the existing `TTFParser` never learns a second container format.
+ *
+ * A WOFF is not a different FONT, it is a different wrapper: the same sfnt tables, each optionally
+ * zlib-compressed, behind a small header. Unpacking it back into an sfnt is therefore the whole job -
+ * every metric, glyph and cmap path downstream stays exactly as it was.
+ *
+ * WOFF2 is deliberately NOT here: it compresses with Brotli, which `fflate` does not do, and it also
+ * TRANSFORMS the glyf/loca tables rather than merely deflating them. That is a different piece of work,
+ * not a bigger version of this one.
+ */
+const SIG_WOFF = 0x774f4646; // "wOFF"
+const HEADER = 44;
+const DIR_ENTRY = 20;
+/** One table may not inflate past this. A single sfnt table above 64 MB is not a real font. */
+const MAX_TABLE_BYTES = 64 * 1024 * 1024;
+/**
+ * And all of them together may not either. The per-table ceiling alone is not a bound: `numTables` is a
+ * uint16, so 65535 directory entries may all point at the SAME small compressed blob, and each would be
+ * inflated and kept. Generous enough for a full CJK face, which is the largest real font there is.
+ */
+const MAX_TOTAL_BYTES = 64 * 1024 * 1024;
+export class WoffError extends Error {
+    constructor(message) {
+        super(`@jasy/pdf: ${message}`);
+    }
+}
+const be32 = (b, at) => ((b[at] << 24) | (b[at + 1] << 16) | (b[at + 2] << 8) | b[at + 3]) >>> 0;
+const be16 = (b, at) => (b[at] << 8) | b[at + 1];
+/** Whether these bytes are a WOFF 1.0 container. Cheap enough to call on every font. */
+export const isWoff = (bytes) => bytes.length >= HEADER && be32(bytes, 0) === SIG_WOFF;
+/**
+ * Unpack a WOFF into the sfnt it wraps. The result is byte-for-byte what a `.ttf` of the same font
+ * would be, apart from table padding, so nothing downstream can tell the difference.
+ */
+export function woffToSfnt(woff) {
+    if (!isWoff(woff))
+        throw new WoffError("these bytes are not a WOFF container");
+    const flavor = be32(woff, 4);
+    const numTables = be16(woff, 12);
+    if (numTables === 0)
+        throw new WoffError("this WOFF declares no tables");
+    if (woff.length < HEADER + numTables * DIR_ENTRY) {
+        throw new WoffError("this WOFF is truncated: its table directory does not fit in the file");
+    }
+    // Read the directory first, then the tables, so a malformed offset is caught before any allocation.
+    const entries = Array.from({ length: numTables }, (_, i) => {
+        const at = HEADER + i * DIR_ENTRY;
+        return {
+            tag: be32(woff, at),
+            offset: be32(woff, at + 4),
+            compLength: be32(woff, at + 8),
+            origLength: be32(woff, at + 12),
+            checksum: be32(woff, at + 16),
+        };
+    });
+    // Tracked across ALL tables, and checked BEFORE each inflate so a hostile directory costs neither the
+    // CPU of unpacking nor the memory of keeping the result.
+    let unpacked = 0;
+    const claim = (bytes) => {
+        unpacked += bytes;
+        if (unpacked > MAX_TOTAL_BYTES) {
+            throw new WoffError(`this WOFF unpacks to more than ${MAX_TOTAL_BYTES} bytes in total; no real font is that large`);
+        }
+    };
+    const tables = entries.map((e) => {
+        if (e.offset + e.compLength > woff.length) {
+            throw new WoffError(`this WOFF is truncated: a table runs past the end of the file`);
+        }
+        claim(e.origLength); // what it DECLARES, before any work is done on it
+        const raw = woff.subarray(e.offset, e.offset + e.compLength);
+        // Equal lengths mean the table was stored as-is; anything else is zlib, per the spec.
+        if (e.compLength === e.origLength)
+            return raw;
+        let out;
+        try {
+            out = inflateBounded(raw, MAX_TABLE_BYTES);
+        }
+        catch (err) {
+            throw new WoffError(`a table in this WOFF could not be unpacked: ${String(err?.message ?? err)}`);
+        }
+        if (out.length !== e.origLength) {
+            throw new WoffError(`a table in this WOFF unpacked to ${out.length} bytes where it declared ${e.origLength}`);
+        }
+        return out;
+    });
+    // Reassemble: offset table, directory, then the tables each padded to a 4-byte boundary.
+    const padded = (n) => (n + 3) & ~3;
+    const dirSize = numTables * 16;
+    const total = 12 + dirSize + tables.reduce((n, t) => n + padded(t.length), 0);
+    const out = new Uint8Array(total);
+    const view = new DataView(out.buffer);
+    // The binary-search hints an sfnt offset table carries. Readers may ignore them; a correct file has
+    // them right, and getting them wrong is the classic way a "valid" font is rejected by a strict one.
+    const entrySelector = Math.floor(Math.log2(numTables));
+    const searchRange = 2 ** entrySelector * 16;
+    view.setUint32(0, flavor);
+    view.setUint16(4, numTables);
+    view.setUint16(6, searchRange);
+    view.setUint16(8, entrySelector);
+    view.setUint16(10, numTables * 16 - searchRange);
+    let dir = 12;
+    let body = 12 + dirSize;
+    entries.forEach((e, i) => {
+        const data = tables[i];
+        view.setUint32(dir, e.tag);
+        view.setUint32(dir + 4, e.checksum);
+        view.setUint32(dir + 8, body);
+        view.setUint32(dir + 12, data.length); // the DECLARED length excludes the padding
+        out.set(data, body);
+        dir += 16;
+        body += padded(data.length);
+    });
+    return out;
+}

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>;