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

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

@@ -1,57 +1,25 @@
-"use strict";
-var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
-    if (k2 === undefined) k2 = k;
-    var desc = Object.getOwnPropertyDescriptor(m, k);
-    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
-      desc = { enumerable: true, get: function() { return m[k]; } };
-    }
-    Object.defineProperty(o, k2, desc);
-}) : (function(o, m, k, k2) {
-    if (k2 === undefined) k2 = k;
-    o[k2] = m[k];
-}));
-var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
-    Object.defineProperty(o, "default", { enumerable: true, value: v });
-}) : function(o, v) {
-    o["default"] = v;
-});
-var __importStar = (this && this.__importStar) || (function () {
-    var ownKeys = function(o) {
-        ownKeys = Object.getOwnPropertyNames || function (o) {
-            var ar = [];
-            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
-            return ar;
-        };
-        return ownKeys(o);
-    };
-    return function (mod) {
-        if (mod && mod.__esModule) return mod;
-        var result = {};
-        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
-        __setModuleDefault(result, mod);
-        return result;
-    };
-})();
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.PDFObjectManager = exports.FontStyle = void 0;
-const page_sizes_1 = require("../constants/page-sizes");
-const fs = __importStar(require("fs"));
-const path = __importStar(require("path"));
-const crypto_1 = require("crypto");
-const zlib_1 = require("zlib");
-const afm_parser_1 = require("./afm-parser");
-const ttf_parser_1 = require("./ttf-parser");
-const ttf_subsetter_1 = require("./ttf-subsetter");
+import { pageFormats, PageSize } from "../constants/page-sizes.js";
+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 { TTFParser } from "./ttf-parser.js";
+import { subsetTTF } from "./ttf-subsetter.js";
+import { getArrayBuffer } from "./utf8-to-windows1252-encoder.js";
 // Enums come from the leaf config module (never in a cycle); the config type is
 // erased at runtime so it can come from the cyclic module safely.
-const pdf_config_1 = require("../renderer/pdf-config");
-var FontStyle;
+import { ColorMode, Orientation } from "../renderer/pdf-config.js";
+export var FontStyle;
 (function (FontStyle) {
     FontStyle["Normal"] = "normal";
     FontStyle["Bold"] = "bold";
     FontStyle["Italic"] = "italic";
     FontStyle["BoldItalic"] = "boldItalic";
-})(FontStyle || (exports.FontStyle = FontStyle = {}));
+})(FontStyle || (FontStyle = {}));
+// Escapes a string into a valid PDF /Name token. A raw space or delimiter in a /Name (e.g. a font
+// family like "Great Vibes" or "Times New Roman") breaks the dictionary, so such chars become #XX.
+const pdfName = (s) => s.replace(/[^\x21-\x7e]|[#()<>[\]{}/%]/g, (c) => "#" + c.charCodeAt(0).toString(16).toUpperCase().padStart(2, "0"));
 // Suffix appended to an embedded font's PDF /BaseFont so each style variant of a family keeps
 // a distinct name (the variants are otherwise selected by the font resource, not the name).
 const STYLE_SUFFIX = {
@@ -152,7 +120,7 @@ class FontManager {
         return `${fontName}-${fontStyle}`;
     }
 }
-class PDFObjectManager {
+export class PDFObjectManager {
     constructor(pageSize) {
         this.objects = [];
         this.objectPositions = [];
@@ -160,7 +128,7 @@ class PDFObjectManager {
         this.fonts = new FontManager(); // Stores the fonts
         this.images = new ImageManager(); // Stores the images (object numbers and names)
         this.extGStates = new ExtGStateManager(); // Transparency states
-        this.pageFormat = page_sizes_1.pageFormats[page_sizes_1.PageSize.A4];
+        this.pageFormat = pageFormats[PageSize.A4];
         this.afmParsers = [];
         // Embedded TrueType fonts, keyed by the name the user registers them under. When a font
         // name is in here the metric/emission paths take the TTF branch instead of the AFM one.
@@ -172,12 +140,13 @@ class PDFObjectManager {
         // the catalog's /Names/EmbeddedFiles + /AF. Drives ZUGFeRD's embedded factur-x.xml.
         this.attachments = [];
         // PDF header version (PDF/A-3 needs 1.7) and whether to write a trailer /ID (PDF/A needs one).
-        // Both default to the pre-PDF/A behaviour, so a normal document stays byte-identical.
+        // Both default to the pre-PDF/A behavior, so a normal document stays byte-identical.
         this.pdfVersion = "1.4";
         this.documentId = false;
         this.compress = false;
+        this.overflowPolicy = "error";
         if (pageSize)
-            this.pageFormat = page_sizes_1.pageFormats[pageSize];
+            this.pageFormat = pageFormats[pageSize];
         this.fillConfigWithStandardValues();
     }
     // Adds an object and returns its number
@@ -198,40 +167,51 @@ 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.
+    setOverflowPolicy(policy) {
+        this.overflowPolicy = policy;
+    }
+    getOverflowPolicy() {
+        return this.overflowPolicy;
+    }
     // Builds a stream object body: `<< extraDict /Length n >> stream … endstream`, FlateDecode-compressed
     // when enabled AND it actually helps (tiny streams aren't inflated). Binary bytes ride as a latin1
     // string - the final encoder passes 0x00-0xFF through unchanged.
     stream(extraDict, data) {
         const head = extraDict ? extraDict + " " : "";
         if (this.compress) {
-            const z = (0, zlib_1.deflateSync)(data);
+            const z = zlibSync(data);
             if (z.length < data.length) {
-                return `<< ${head}/Filter /FlateDecode /Length ${z.length} >>\nstream\n${z.toString("latin1")}\nendstream`;
+                return `<< ${head}/Filter /FlateDecode /Length ${z.length} >>\nstream\n${latin1FromBytes(z)}\nendstream`;
             }
         }
-        return `<< ${head}/Length ${data.length} >>\nstream\n${data.toString("latin1")}\nendstream`;
+        return `<< ${head}/Length ${data.length} >>\nstream\n${latin1FromBytes(data)}\nendstream`;
     }
     // Adds a page content stream (compressed when enabled). The caller passes the raw operator string.
+    // Bytes go through the Windows-1252 encoder (NOT a latin1 low-byte cast): a Tj literal may carry a
+    // CP1252 char like "…"/"—"/"€" whose codepoint is > 0xFF, and latin1 would mangle it (… -> "&").
+    // For every char <= 0xFF the encoder passes the byte through, so existing streams stay byte-identical.
     addContentStream(content) {
-        return this.addObject(this.stream("", Buffer.from(content, "latin1")));
+        return this.addObject(this.stream("", new Uint8Array(getArrayBuffer(content))));
     }
     changePDFConfig(config) {
-        this.pdfConfig = Object.assign(Object.assign({}, this.pdfConfig), config);
+        this.pdfConfig = { ...this.pdfConfig, ...config };
     }
     getPDFConfig() {
         return this.pdfConfig;
     }
     fillConfigWithStandardValues() {
         this.pdfConfig = {
-            orientation: pdf_config_1.Orientation.portrait,
+            orientation: Orientation.portrait,
             defaultFont: {
                 fontFamily: "Helvetica",
                 fontSize: 12,
                 fontStyle: FontStyle.Normal,
             },
-            pageSize: page_sizes_1.PageSize.A4,
+            pageSize: PageSize.A4,
             margin: { left: 72, top: 72, bottom: 72, right: 72 },
-            colorMode: pdf_config_1.ColorMode.color,
+            colorMode: ColorMode.color,
         };
     }
     // Calculates the total length of the document in bytes (for XRef)
@@ -240,10 +220,8 @@ class PDFObjectManager {
         for (let i = 0; i < this.objects.length; i++) {
             const obj = this.objects[i];
             const objectContent = `${i + 1} 0 obj\n${obj}\nendobj\n`;
-            // Convert the object content into a buffer with the correct encoding
-            const encodedContent = Buffer.from(objectContent, "binary");
-            // Add the actual byte length to the total length
-            length += encodedContent.length;
+            // The body is a latin1/binary string (every char <= 0xFF), so its length IS its byte length.
+            length += objectContent.length;
         }
         return length;
     }
@@ -256,7 +234,23 @@ class PDFObjectManager {
         return this.parentObjectNumber;
     }
     // Registers an image
-    registerImage(width, height, imageType, imageData) {
+    registerImage(width, height, imageType, imageData, smaskData) {
+        // A transparent PNG carries its alpha as a separate DeviceGray /SMask image the viewer composites with.
+        let smaskEntry = "";
+        if (smaskData) {
+            const smaskObject = `<< /Type /XObject
+    /Subtype /Image
+    /Width ${width}
+    /Height ${height}
+    /ColorSpace /DeviceGray
+    /BitsPerComponent 8
+    /Filter /FlateDecode
+    /Length ${smaskData.length} >>
+stream
+${smaskData}
+endstream`;
+            smaskEntry = `    /SMask ${this.addObject(smaskObject)} 0 R\n`;
+        }
         const imageObject = `<< /Type /XObject
     /Subtype /Image
     /Width ${width}
@@ -264,9 +258,9 @@ class PDFObjectManager {
     /ColorSpace /DeviceRGB
     /BitsPerComponent 8
     /Filter /${imageType}
-    /Length ${imageData.length} >>
+${smaskEntry}    /Length ${imageData.length} >>
 stream
-${imageData} 
+${imageData}
 endstream`;
         // Add the image and its object number to the image manager - return the object number
         const imageObjectNumber = this.addObject(imageObject);
@@ -278,13 +272,12 @@ endstream`;
     // `relationship` is the /AFRelationship (e.g. "Data" for the ZUGFeRD factur-x.xml). Binary bytes
     // ride as a latin1 string, like images/fonts (the final encoder passes 0x00-0xFF through).
     attachFile(name, data, opts = {}) {
-        var _a, _b;
-        const subtype = ((_a = opts.mimeType) !== null && _a !== void 0 ? _a : "application/octet-stream").replace(/\//g, "#2F");
+        const subtype = (opts.mimeType ?? "application/octet-stream").replace(/\//g, "#2F");
         const embedded = this.addObject(this.stream(`/Type /EmbeddedFile /Subtype /${subtype} /Params << /Size ${data.length} >>`, data));
         const escaped = (s) => s.replace(/\\/g, "\\\\").replace(/\(/g, "\\(").replace(/\)/g, "\\)");
         const desc = opts.description ? ` /Desc (${escaped(opts.description)})` : "";
         const filespec = this.addObject(`<< /Type /Filespec /F (${escaped(name)}) /UF (${escaped(name)}) ` +
-            `/AFRelationship /${(_b = opts.relationship) !== null && _b !== void 0 ? _b : "Unspecified"}${desc} ` +
+            `/AFRelationship /${opts.relationship ?? "Unspecified"}${desc} ` +
             `/EF << /F ${embedded} 0 R /UF ${embedded} 0 R >> >>`);
         this.attachments.push({ name, filespec });
     }
@@ -302,11 +295,10 @@ endstream`;
     // Embeds an ICC profile and a PDF/A /OutputIntent that points at it (catalog /OutputIntents).
     // `icc` are the raw profile bytes (an RGB profile, /N 3 - e.g. sRGB).
     setOutputIntent(icc, opts = {}) {
-        var _a, _b;
         const profile = this.addObject(this.stream("/N 3", icc));
         this.outputIntent = this.addObject(`<< /Type /OutputIntent /S /GTS_PDFA1 ` +
-            `/OutputConditionIdentifier (${(_a = opts.identifier) !== null && _a !== void 0 ? _a : "sRGB"}) ` +
-            `/Info (${(_b = opts.info) !== null && _b !== void 0 ? _b : "sRGB IEC61966-2.1"}) /DestOutputProfile ${profile} 0 R >>`);
+            `/OutputConditionIdentifier (${opts.identifier ?? "sRGB"}) ` +
+            `/Info (${opts.info ?? "sRGB IEC61966-2.1"}) /DestOutputProfile ${profile} 0 R >>`);
     }
     getOutputIntent() {
         return this.outputIntent;
@@ -354,20 +346,19 @@ endstream`;
         if (this.fonts.hasFont(fontName, fontStyle)) {
             return this.fonts.getFont(fontName, fontStyle); // Already exists? Return it!
         }
-        const afmFilePath = path.resolve(__dirname, "../", `assets/${fullName}.afm`);
-        if (fs.existsSync(afmFilePath)) {
-            const data = fs.readFileSync(afmFilePath, "utf-8");
+        const data = STANDARD_AFM[fullName];
+        if (data !== undefined) {
             this.afmParsers.push({
                 fontName,
                 fontStyle,
                 fullFontName: fullName,
-                parser: new afm_parser_1.AFMParser(data),
+                parser: new AFMParser(data),
             });
         }
         const resourceNumber = this.objects.length + 1; // New resource number
         const fontNumber = this.fonts.getLastFontIndex() + 1; // New font index number
         this.fonts.addFont(fontName, fontNumber, resourceNumber, fontStyle); // Store it
-        const fontObject = `<</BaseFont/${fullName}/Type/Font\n/Encoding/WinAnsiEncoding\n/Subtype/Type1>>`;
+        const fontObject = `<</BaseFont/${pdfName(fullName)}/Type/Font\n/Encoding/WinAnsiEncoding\n/Subtype/Type1>>`;
         this.addObject(fontObject);
         return {
             fontIndex: fontNumber,
@@ -383,7 +374,7 @@ endstream`;
         const key = this.customKey(name, style);
         if (this.customFonts.has(key))
             return;
-        this.customFonts.set(key, new ttf_parser_1.TTFParser(data));
+        this.customFonts.set(key, new TTFParser(data));
         // 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.
@@ -429,9 +420,7 @@ endstream`;
     }
     // A deterministic 6-uppercase-letter subset tag (PDF/A wants the "TAG+FontName" form).
     subsetTag(pdfName, used) {
-        const h = (0, crypto_1.createHash)("md5")
-            .update(pdfName + [...used].sort((a, b) => a - b).join(","))
-            .digest();
+        const h = md5(new TextEncoder().encode(pdfName + [...used].sort((a, b) => a - b).join(",")));
         let tag = "";
         for (let i = 0; i < 6; i++)
             tag += String.fromCharCode(65 + (h[i] % 26));
@@ -489,13 +478,13 @@ endstream`;
     // The SUBSET font program (only the used glyphs' outlines). Binary bytes survive as a latin1
     // string - the final Windows-1252 encoder passes 0x00-0xFF through unchanged (see getArrayBuffer).
     buildFontFile2(ttf, used) {
-        const bytes = (0, ttf_subsetter_1.subsetTTF)(ttf.getData(), used);
+        const bytes = subsetTTF(ttf.getData(), used);
         // /Length1 is the UNCOMPRESSED font-program length (required even when FlateDecode'd).
         return this.stream(`/Length1 ${bytes.length}`, bytes);
     }
     buildFontDescriptor(name, ttf, fontFile) {
         const [x0, y0, x1, y1] = ttf.bbox;
-        return (`<< /Type /FontDescriptor /FontName /${name} /Flags 4 ` +
+        return (`<< /Type /FontDescriptor /FontName /${pdfName(name)} /Flags 4 ` +
             `/FontBBox [${x0} ${y0} ${x1} ${y1}] /ItalicAngle 0 ` +
             `/Ascent ${ttf.ascent} /Descent ${ttf.descent} /CapHeight ${ttf.ascent} /StemV 80 ` +
             `/FontFile2 ${fontFile} 0 R >>`);
@@ -506,9 +495,9 @@ endstream`;
         const all = ttf.glyphWidths();
         const w = [...used]
             .sort((a, b) => a - b)
-            .map((g) => { var _a; return `${g} [${(_a = all[g]) !== null && _a !== void 0 ? _a : 1000}]`; })
+            .map((g) => `${g} [${all[g] ?? 1000}]`)
             .join(" ");
-        return (`<< /Type /Font /Subtype /CIDFontType2 /BaseFont /${name} ` +
+        return (`<< /Type /Font /Subtype /CIDFontType2 /BaseFont /${pdfName(name)} ` +
             `/CIDSystemInfo << /Registry (Adobe) /Ordering (Identity) /Supplement 0 >> ` +
             `/FontDescriptor ${descriptor} 0 R /CIDToGIDMap /Identity ` +
             `/DW 1000 /W [${w}] >>`);
@@ -533,10 +522,10 @@ endstream`;
             `/CMapName /Adobe-Identity-UCS def\n/CMapType 2 def\n` +
             `1 begincodespacerange\n<0000> <FFFF>\nendcodespacerange\n${blocks.join("\n")}\n` +
             `endcmap\nCMapName currentdict /CMap defineresource pop\nend\nend`;
-        return this.stream("", Buffer.from(body, "latin1"));
+        return this.stream("", bytesFromLatin1(body));
     }
     buildType0(name, cidFont, toUnicode) {
-        return (`<< /Type /Font /Subtype /Type0 /BaseFont /${name} /Encoding /Identity-H ` +
+        return (`<< /Type /Font /Subtype /Type0 /BaseFont /${pdfName(name)} /Encoding /Identity-H ` +
             `/DescendantFonts [${cidFont} 0 R] /ToUnicode ${toUnicode} 0 R >>`);
     }
     // Returns the current width of a text, included kernings
@@ -561,6 +550,11 @@ endstream`;
         return char.charCodeAt(0).toString();
     }
     getAVMParserByFont(fullFontName, fontName, fontStyle) {
+        // A non-string family means font bytes were passed where a name belongs - hint at the fix instead of
+        // stringifying the byte blob into an unreadable "parser not found".
+        for (const name of [fullFontName, fontName])
+            if (name != null && typeof name !== "string")
+                throw new Error(`Font family must be a string name, got ${typeof name}. Register font bytes via the document \`fonts\` map (or addFont) and reference them by name.`);
         if (!fullFontName && (!fontName || !fontStyle)) {
             throw new Error("No font family is given. Please set a full font name or a font with font style");
         }
@@ -577,14 +571,16 @@ endstream`;
     }
     // Methode zur Berechnung der Zeichenbreite anhand der Schriftgröße
     getCharWidth(char, fontSize, fullFontName, fontName, fontStyle) {
-        const ttf = this.getCustomFont(fullFontName !== null && fullFontName !== void 0 ? fullFontName : fontName, fontStyle);
+        const ttf = this.getCustomFont(fullFontName ?? fontName, fontStyle);
         if (ttf)
             return ttf.getCharWidth(char, fontSize);
         const currentParser = this.getAVMParserByFont(fullFontName, fontName, fontStyle);
-        const advanceWidth = currentParser.parser.getAdvanceWidth(char);
-        // Normally we got still zero. TODO: Return a alternative width like the "space"
+        let advanceWidth = currentParser.parser.getAdvanceWidth(char);
+        // A character a standard font cannot represent (not in Windows-1252) is drawn as "?" by the
+        // encoder; measure it as "?" too so the width matches the glyph - graceful instead of a crash.
         if (!advanceWidth) {
-            throw new Error(`Kein Metrik-Eintrag für Zeichen: ${char} ${this.getCharCode(char)}`);
+            advanceWidth =
+                currentParser.parser.getAdvanceWidth("?") || currentParser.parser.getAdvanceWidth(" ");
         }
         // Width of the character multiplied by the font size (scaled proportionally)
         return (advanceWidth / 1000) * fontSize;
@@ -592,7 +588,7 @@ endstream`;
     // 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 !== null && fullFontName !== void 0 ? fullFontName : fontName, fontStyle))
+        if (this.getCustomFont(fullFontName ?? fontName, fontStyle))
             return 0;
         const currentParser = this.getAVMParserByFont(fullFontName, fontName, fontStyle);
         return currentParser.parser.getKerning(char, nextChar) / 1000;
@@ -635,11 +631,10 @@ endstream`;
         return `trailer\n<< /Size ${objectCount + 1} /Root ${root} 0 R${id} >>\nstartxref\n${startxref}\n%%EOF`;
     }
     contentId() {
-        return `<${(0, crypto_1.createHash)("md5").update(this.objects.join("")).digest("hex").toUpperCase()}>`;
+        return `<${md5Hex(new TextEncoder().encode(this.objects.join(""))).toUpperCase()}>`;
     }
     // Returns the number of objects
     getObjectCount() {
         return this.objects.length;
     }
 }
-exports.PDFObjectManager = PDFObjectManager;

package/dist/utils/renderer-registry.js

@@ -1,7 +1,4 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.RendererRegistry = void 0;
-class RendererRegistry {
+export class RendererRegistry {
     static register(elementClass, renderer) {
         if (!RendererRegistry.renderers.has(elementClass)) {
             RendererRegistry.renderers.set(elementClass, renderer);
@@ -15,5 +12,4 @@ class RendererRegistry {
         return renderer.constructor.name === "AsyncFunction";
     }
 }
-exports.RendererRegistry = RendererRegistry;
 RendererRegistry.renderers = new Map();

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

@@ -10,8 +10,8 @@ export declare class TTFParser {
     private cmap;
     private cmapGroups;
     private tables;
-    constructor(data: Buffer);
-    getData(): Buffer;
+    constructor(data: Uint8Array);
+    getData(): Uint8Array;
     glyphCount(): number;
     glyphWidths(): number[];
     reverseCmap(): Map<number, number>;

package/dist/utils/ttf-parser.js

@@ -1,10 +1,8 @@
-"use strict";
 // Parses the metric tables of a TrueType (.ttf) font - the binary counterpart to AFMParser.
 // 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.
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.TTFParser = void 0;
-class TTFParser {
+import { i16, latin1FromBytes, u16, u32 } from "./bytes.js";
+export class TTFParser {
     constructor(data) {
         this.data = data;
         this.unitsPerEm = 1000;
@@ -20,18 +18,18 @@ class TTFParser {
         this.tables = {};
         this.readTableDirectory();
         const head = this.table("head").offset;
-        this.unitsPerEm = this.data.readUInt16BE(head + 18);
-        this.numGlyphs = this.data.readUInt16BE(this.table("maxp").offset + 4);
-        this.numHMetrics = this.data.readUInt16BE(this.table("hhea").offset + 34);
+        this.unitsPerEm = u16(this.data, head + 18);
+        this.numGlyphs = u16(this.data, this.table("maxp").offset + 4);
+        this.numHMetrics = u16(this.data, this.table("hhea").offset + 34);
         this.bbox = [
-            this.toGlyphSpace(this.data.readInt16BE(head + 36)), // xMin
-            this.toGlyphSpace(this.data.readInt16BE(head + 38)), // yMin
-            this.toGlyphSpace(this.data.readInt16BE(head + 40)), // xMax
-            this.toGlyphSpace(this.data.readInt16BE(head + 42)), // yMax
+            this.toGlyphSpace(i16(this.data, head + 36)), // xMin
+            this.toGlyphSpace(i16(this.data, head + 38)), // yMin
+            this.toGlyphSpace(i16(this.data, head + 40)), // xMax
+            this.toGlyphSpace(i16(this.data, head + 42)), // yMax
         ];
         const hhea = this.table("hhea").offset;
-        this.ascent = this.toGlyphSpace(this.data.readInt16BE(hhea + 4));
-        this.descent = this.toGlyphSpace(this.data.readInt16BE(hhea + 6));
+        this.ascent = this.toGlyphSpace(i16(this.data, hhea + 4));
+        this.descent = this.toGlyphSpace(i16(this.data, hhea + 6));
         this.readHmtx();
         this.readCmap();
     }
@@ -76,9 +74,8 @@ class TTFParser {
     }
     // Advance width of a glyph in font units. Glyphs past numHMetrics reuse the last advance.
     getAdvanceWidth(glyphIndex) {
-        var _a;
         const i = Math.min(glyphIndex, this.numHMetrics - 1);
-        return (_a = this.advanceWidths[i]) !== null && _a !== void 0 ? _a : 0;
+        return this.advanceWidths[i] ?? 0;
     }
     // Char width at fontSize, scaled from font units (em = unitsPerEm) to points.
     getCharWidth(char, fontSize) {
@@ -99,13 +96,13 @@ class TTFParser {
         return t;
     }
     readTableDirectory() {
-        const numTables = this.data.readUInt16BE(4);
+        const numTables = u16(this.data, 4);
         let p = 12; // after the offset table (sfntVersion + numTables + 3 fields)
         for (let i = 0; i < numTables; i++) {
-            const tag = this.data.toString("latin1", p, p + 4);
+            const tag = latin1FromBytes(this.data.subarray(p, p + 4));
             this.tables[tag] = {
-                offset: this.data.readUInt32BE(p + 8),
-                length: this.data.readUInt32BE(p + 12),
+                offset: u32(this.data, p + 8),
+                length: u32(this.data, p + 12),
             };
             p += 16;
         }
@@ -116,20 +113,20 @@ class TTFParser {
         let last = 0;
         for (let i = 0; i < this.numGlyphs; i++) {
             if (i < this.numHMetrics)
-                last = this.data.readUInt16BE(o + i * 4);
+                last = u16(this.data, o + i * 4);
             this.advanceWidths.push(last);
         }
     }
     readCmap() {
         const base = this.table("cmap").offset;
-        const numTables = this.data.readUInt16BE(base + 2);
+        const numTables = u16(this.data, base + 2);
         // Prefer the Windows Unicode BMP subtable (3,1); accept full-Unicode (3,10) or any (0,x).
         let subtable = -1;
         let p = base + 4;
         for (let i = 0; i < numTables; i++) {
-            const platform = this.data.readUInt16BE(p);
-            const encoding = this.data.readUInt16BE(p + 2);
-            const offset = this.data.readUInt32BE(p + 4);
+            const platform = u16(this.data, p);
+            const encoding = u16(this.data, p + 2);
+            const offset = u32(this.data, p + 4);
             const unicode = (platform === 3 && (encoding === 1 || encoding === 10)) || platform === 0;
             if (unicode) {
                 subtable = base + offset;
@@ -140,7 +137,7 @@ class TTFParser {
         }
         if (subtable < 0)
             return;
-        const format = this.data.readUInt16BE(subtable);
+        const format = u16(this.data, subtable);
         if (format === 4)
             this.readCmapFormat4(subtable);
         else if (format === 12)
@@ -149,23 +146,23 @@ class TTFParser {
     // Format 4: segment mapping. Four parallel arrays keyed by segment; the glyph comes either
     // from idDelta or, when idRangeOffset != 0, from the glyphIdArray it points into.
     readCmapFormat4(o) {
-        const segCountX2 = this.data.readUInt16BE(o + 6);
+        const segCountX2 = u16(this.data, o + 6);
         const endCodes = o + 14;
         const startCodes = endCodes + segCountX2 + 2; // +2 reservedPad
         const idDeltas = startCodes + segCountX2;
         const idRangeOffsets = idDeltas + segCountX2;
         for (let i = 0; i < segCountX2 / 2; i++) {
-            const end = this.data.readUInt16BE(endCodes + i * 2);
-            const start = this.data.readUInt16BE(startCodes + i * 2);
-            const delta = this.data.readUInt16BE(idDeltas + i * 2);
-            const rangeOffset = this.data.readUInt16BE(idRangeOffsets + i * 2);
+            const end = u16(this.data, endCodes + i * 2);
+            const start = u16(this.data, startCodes + i * 2);
+            const delta = u16(this.data, idDeltas + i * 2);
+            const rangeOffset = u16(this.data, idRangeOffsets + i * 2);
             for (let c = start; c <= end && c !== 0xffff; c++) {
                 let glyph;
                 if (rangeOffset === 0) {
                     glyph = (c + delta) & 0xffff;
                 }
                 else {
-                    glyph = this.data.readUInt16BE(idRangeOffsets + i * 2 + rangeOffset + (c - start) * 2);
+                    glyph = u16(this.data, idRangeOffsets + i * 2 + rangeOffset + (c - start) * 2);
                     if (glyph !== 0)
                         glyph = (glyph + delta) & 0xffff;
                 }
@@ -176,16 +173,15 @@ class TTFParser {
     }
     // Format 12: sequential groups for full Unicode (incl. astral). Kept un-expanded.
     readCmapFormat12(o) {
-        const nGroups = this.data.readUInt32BE(o + 12);
+        const nGroups = u32(this.data, o + 12);
         let p = o + 16;
         for (let i = 0; i < nGroups; i++) {
             this.cmapGroups.push({
-                start: this.data.readUInt32BE(p),
-                end: this.data.readUInt32BE(p + 4),
-                startGlyph: this.data.readUInt32BE(p + 8),
+                start: u32(this.data, p),
+                end: u32(this.data, p + 4),
+                startGlyph: u32(this.data, p + 8),
             });
             p += 12;
         }
     }
 }
-exports.TTFParser = TTFParser;

package/dist/utils/ttf-subsetter.d.ts

@@ -1 +1 @@
-export declare function subsetTTF(data: Buffer, used: Set<number>): Buffer;
+export declare function subsetTTF(data: Uint8Array, used: Set<number>): Uint8Array;