@jasy/pdf 1.0.0-alpha.1

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

@@ -0,0 +1,645 @@
+"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");
+// 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;
+(function (FontStyle) {
+    FontStyle["Normal"] = "normal";
+    FontStyle["Bold"] = "bold";
+    FontStyle["Italic"] = "italic";
+    FontStyle["BoldItalic"] = "boldItalic";
+})(FontStyle || (exports.FontStyle = FontStyle = {}));
+// 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 = {
+    [FontStyle.Normal]: "",
+    [FontStyle.Bold]: "-Bold",
+    [FontStyle.Italic]: "-Italic",
+    [FontStyle.BoldItalic]: "-BoldItalic",
+};
+class ImageManager {
+    constructor() {
+        this.images = new Map();
+    }
+    addImage(resourceNumber) {
+        this.images.set("IM" + resourceNumber.toString(), resourceNumber);
+    }
+    getAllImages() {
+        return this.images;
+    }
+}
+/** Graphics-state objects for transparency, deduped by their (fill, stroke) alpha pair. */
+class ExtGStateManager {
+    constructor() {
+        // alpha-pair key -> { resource name, indirect-object number }
+        this.states = new Map();
+    }
+    get(key) {
+        return this.states.get(key);
+    }
+    add(key, name, objectNumber) {
+        this.states.set(key, { name, objectNumber });
+    }
+    size() {
+        return this.states.size;
+    }
+    /** name -> object number, for the page `/Resources /ExtGState` dict. */
+    getAll() {
+        const out = new Map();
+        this.states.forEach((value) => out.set(value.name, value.objectNumber));
+        return out;
+    }
+}
+class FontManager {
+    constructor() {
+        this.fonts = new Map();
+    }
+    addFont(fontName, fontIndex, resourceIndex, fontStyle = FontStyle.Normal, fullName = fontName, force = false) {
+        const fontKey = this._createFontKey(fontName, fontStyle);
+        // `force` lets an embedded custom font override a same-named standard-14 entry (e.g. embedding
+        // "Helvetica" as Liberation for PDF/A) - otherwise the standard /Type1 resource would win and
+        // the CID text would be drawn against the wrong font.
+        if (force || !this.fonts.has(fontKey)) {
+            this.fonts.set(fontKey, {
+                fontIndex,
+                resourceIndex,
+                fontStyle,
+                fullName,
+            });
+        }
+    }
+    hasFont(fontName, fontStyle = FontStyle.Normal) {
+        const fontKey = this._createFontKey(fontName, fontStyle);
+        return this.fonts.has(fontKey);
+    }
+    getFont(fontName, fontStyle = FontStyle.Normal) {
+        const fontKey = this._createFontKey(fontName, fontStyle);
+        return this.fonts.get(fontKey);
+    }
+    addCustomFont(fontName, fontStyle, fullName = fontName) {
+        const fontIndex = this.getLastFontIndex() + 1;
+        const resourceIndex = this.getLastResourceIndex() + 1;
+        this.addFont(fontName, fontIndex, resourceIndex, fontStyle, fullName);
+    }
+    getAllFonts() {
+        return this.fonts;
+    }
+    size() {
+        return this.fonts.size;
+    }
+    getLastFontIndex() {
+        let maxFontIndex = 0;
+        this.fonts.forEach((value) => {
+            if (value.fontIndex > maxFontIndex) {
+                maxFontIndex = value.fontIndex;
+            }
+        });
+        return maxFontIndex;
+    }
+    getLastResourceIndex() {
+        let maxResourceIndex = 0;
+        this.fonts.forEach((value) => {
+            if (value.resourceIndex > maxResourceIndex) {
+                maxResourceIndex = value.resourceIndex;
+            }
+        });
+        return maxResourceIndex;
+    }
+    _createFontKey(fontName, fontStyle) {
+        return `${fontName}-${fontStyle}`;
+    }
+}
+class PDFObjectManager {
+    constructor(pageSize) {
+        this.objects = [];
+        this.objectPositions = [];
+        this.parentObjectNumber = 0;
+        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.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.
+        this.customFonts = 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();
+        // Embedded file attachments (their /Filespec object numbers + display names). Referenced from
+        // 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.
+        this.pdfVersion = "1.4";
+        this.documentId = false;
+        this.compress = false;
+        if (pageSize)
+            this.pageFormat = page_sizes_1.pageFormats[pageSize];
+        this.fillConfigWithStandardValues();
+    }
+    // Adds an object and returns its number
+    addObject(content) {
+        // The text is encoded in Windows-1252 if necessary
+        const objectNumber = this.objects.length + 1;
+        const position = this.getCurrentByteLength(); // Calculate the current byte length
+        this.objectPositions.push(position);
+        this.objects.push(content);
+        return objectNumber;
+    }
+    // Replaces an object at the index `objectNumber`
+    replaceObject(objectNumber, content) {
+        this.objects[objectNumber - 1] = content;
+    }
+    // FlateDecode compression for stream payloads (default off; renderPdf turns it on). Off keeps the
+    // PDF greppable for debugging and the internal tests; the XMP metadata stream is never routed here.
+    setCompress(on) {
+        this.compress = on;
+    }
+    // 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);
+            if (z.length < data.length) {
+                return `<< ${head}/Filter /FlateDecode /Length ${z.length} >>\nstream\n${z.toString("latin1")}\nendstream`;
+            }
+        }
+        return `<< ${head}/Length ${data.length} >>\nstream\n${data.toString("latin1")}\nendstream`;
+    }
+    // Adds a page content stream (compressed when enabled). The caller passes the raw operator string.
+    addContentStream(content) {
+        return this.addObject(this.stream("", Buffer.from(content, "latin1")));
+    }
+    changePDFConfig(config) {
+        this.pdfConfig = Object.assign(Object.assign({}, this.pdfConfig), config);
+    }
+    getPDFConfig() {
+        return this.pdfConfig;
+    }
+    fillConfigWithStandardValues() {
+        this.pdfConfig = {
+            orientation: pdf_config_1.Orientation.portrait,
+            defaultFont: {
+                fontFamily: "Helvetica",
+                fontSize: 12,
+                fontStyle: FontStyle.Normal,
+            },
+            pageSize: page_sizes_1.PageSize.A4,
+            margin: { left: 72, top: 72, bottom: 72, right: 72 },
+            colorMode: pdf_config_1.ColorMode.color,
+        };
+    }
+    // Calculates the total length of the document in bytes (for XRef)
+    getCurrentByteLength() {
+        let length = this.getHeader().length; // Start with the header
+        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;
+        }
+        return length;
+    }
+    // Sets the parent object number
+    setParentObjectNumber(number) {
+        this.parentObjectNumber = number;
+    }
+    // Returns the parent object number
+    getParentObjectNumber() {
+        return this.parentObjectNumber;
+    }
+    // Registers an image
+    registerImage(width, height, imageType, imageData) {
+        const imageObject = `<< /Type /XObject
+    /Subtype /Image
+    /Width ${width}
+    /Height ${height}
+    /ColorSpace /DeviceRGB
+    /BitsPerComponent 8
+    /Filter /${imageType}
+    /Length ${imageData.length} >>
+stream
+${imageData} 
+endstream`;
+        // Add the image and its object number to the image manager - return the object number
+        const imageObjectNumber = this.addObject(imageObject);
+        this.images.addImage(imageObjectNumber);
+        return imageObjectNumber;
+    }
+    // Embeds a file as an associated file (PDF/A-3 / PDF 2.0): an /EmbeddedFile stream + a /Filespec.
+    // The catalog wiring (/Names/EmbeddedFiles + /AF) is added by PDFRenderer when attachments exist.
+    // `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 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} ` +
+            `/EF << /F ${embedded} 0 R /UF ${embedded} 0 R >> >>`);
+        this.attachments.push({ name, filespec });
+    }
+    // Filespec object numbers + names, for the catalog's /Names/EmbeddedFiles and /AF.
+    getAttachments() {
+        return this.attachments;
+    }
+    // Sets the document XMP packet (catalog /Metadata). ASCII expected (see the field comment).
+    setXmpMetadata(xml) {
+        this.xmpMetadata = xml;
+    }
+    getXmpMetadata() {
+        return this.xmpMetadata;
+    }
+    // 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 >>`);
+    }
+    getOutputIntent() {
+        return this.outputIntent;
+    }
+    // PDF header version, e.g. "1.7" for PDF/A-3. Always "1.X" so the 9-byte header length (and the
+    // xref offsets that depend on it) never change.
+    setPdfVersion(version) {
+        this.pdfVersion = version;
+    }
+    getPdfVersion() {
+        return this.pdfVersion;
+    }
+    // The full PDF header: the version line + a binary-marker comment whose 4 bytes are all > 127
+    // (PDF/A clause 6.1.2). Every char is <= 0xFF, so the string length equals the emitted byte
+    // length - which the xref offset calculation relies on.
+    getHeader() {
+        // The marker is `%` + â ã Ï Ó (Latin-1 0xE2 0xE3 0xCF 0xD3, all > 127); each char is <= 0xFF so
+        // the final encoder emits it as that exact byte.
+        return `%PDF-${this.pdfVersion}\n%âãÏÓ\n`;
+    }
+    // Enables a trailer /ID (required by PDF/A). The id is a content hash, so it is deterministic.
+    enableDocumentId() {
+        this.documentId = true;
+    }
+    // Registers (or reuses) a transparency graphics state and returns its resource name
+    // (e.g. "GS1"). `fillAlpha` -> /ca, `strokeAlpha` -> /CA. Deduped by the alpha pair.
+    registerExtGState(fillAlpha, strokeAlpha) {
+        const ca = fillAlpha.toFixed(3);
+        const CA = strokeAlpha.toFixed(3);
+        const key = `${ca}:${CA}`;
+        const existing = this.extGStates.get(key);
+        if (existing)
+            return existing.name;
+        const name = `GS${this.extGStates.size() + 1}`;
+        const objectNumber = this.addObject(`<< /Type /ExtGState /ca ${ca} /CA ${CA} >>`);
+        this.extGStates.add(key, name, objectNumber);
+        return name;
+    }
+    // Returns all registered transparency states (name -> object number) for the page
+    getAllExtGStatesRaw() {
+        return this.extGStates.getAll();
+    }
+    // Registers a font
+    registerFont(fontName, fontStyle = FontStyle.Normal, fullName = fontName) {
+        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");
+            this.afmParsers.push({
+                fontName,
+                fontStyle,
+                fullFontName: fullName,
+                parser: new afm_parser_1.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>>`;
+        this.addObject(fontObject);
+        return {
+            fontIndex: fontNumber,
+            resourceIndex: resourceNumber,
+            fontStyle: fontStyle,
+            fullName: fullName,
+        };
+    }
+    // Registers one variant (default Normal) of an embedded TrueType family `name`: stores it for
+    // metrics and emits its PDF font objects. All variants share the family `name`; bold/italic are
+    // separate .ttf files registered under the same name with a different style.
+    registerCustomFont(name, data, style = FontStyle.Normal) {
+        const key = this.customKey(name, style);
+        if (this.customFonts.has(key))
+            return;
+        this.customFonts.set(key, new ttf_parser_1.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.
+    }
+    // Reserves the font objects and registers the page resource the FIRST time a face is actually
+    // used. Idempotent; `style` is the already-resolved variant.
+    ensureEmitted(name, style) {
+        const key = this.customKey(name, style);
+        if (this.customFontEmit.has(key))
+            return;
+        // Reserve the font objects (dependency order so each reference points at an already-numbered
+        // object); their content - a SUBSET of the font - is filled in by finalizeCustomFonts().
+        const fontFile = this.addObject("<< >>");
+        const descriptor = this.addObject("<< >>");
+        const cidFont = this.addObject("<< >>");
+        const toUnicode = this.addObject("<< >>");
+        const type0 = this.addObject("<< >>");
+        // The Type0 dict is the resource the page references (/F{index} -> type0 object). `force` so an
+        // embedded font overrides a same-named standard-14 entry instead of being silently dropped.
+        this.fonts.addFont(name, this.fonts.getLastFontIndex() + 1, type0, style, name, true);
+        this.customFontEmit.set(key, {
+            pdfName: name + STYLE_SUFFIX[style],
+            fontFile,
+            descriptor,
+            cidFont,
+            toUnicode,
+            type0,
+            used: new Set([0]), // .notdef always present
+        });
+    }
+    // Fills the reserved font objects with a SUBSET of each font (only the glyphs the document used),
+    // tagged "ABCDEF+" as PDF/A requires for subsets. Call once, after the render pass, before output.
+    finalizeCustomFonts() {
+        for (const [key, e] of this.customFontEmit) {
+            const ttf = this.customFonts.get(key);
+            const base = `${this.subsetTag(e.pdfName, e.used)}+${e.pdfName}`;
+            this.replaceObject(e.fontFile, this.buildFontFile2(ttf, e.used));
+            this.replaceObject(e.descriptor, this.buildFontDescriptor(base, ttf, e.fontFile));
+            this.replaceObject(e.cidFont, this.buildCIDFont(base, ttf, e.descriptor, e.used));
+            this.replaceObject(e.toUnicode, this.buildToUnicode(ttf, e.used));
+            this.replaceObject(e.type0, this.buildType0(base, e.cidFont, e.toUnicode));
+        }
+    }
+    // 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();
+        let tag = "";
+        for (let i = 0; i < 6; i++)
+            tag += String.fromCharCode(65 + (h[i] % 26));
+        return tag;
+    }
+    customKey(name, style) {
+        return `${name}-${style}`;
+    }
+    // The variant to actually use for (name, style): the requested style if registered, else the
+    // family's Normal as a clean fallback (e.g. bold chosen but no bold file), else undefined when
+    // `name` is not a custom family at all.
+    resolveCustomStyle(name, style = FontStyle.Normal) {
+        if (!name)
+            return undefined;
+        if (this.customFonts.has(this.customKey(name, style)))
+            return style;
+        if (this.customFonts.has(this.customKey(name, FontStyle.Normal)))
+            return FontStyle.Normal;
+        return undefined;
+    }
+    getCustomFont(name, style = FontStyle.Normal) {
+        const resolved = this.resolveCustomStyle(name, style);
+        return resolved ? this.customFonts.get(this.customKey(name, resolved)) : undefined;
+    }
+    isCustomFont(name, style = FontStyle.Normal) {
+        return !!this.resolveCustomStyle(name, style);
+    }
+    // The page font resource for the resolved variant - same resolution as getCustomFont, so the
+    // selected Type0 object and the emitted glyph ids always come from the SAME font file.
+    getCustomFontResource(name, style = FontStyle.Normal) {
+        const resolved = this.resolveCustomStyle(name, style);
+        if (!resolved)
+            return undefined;
+        this.ensureEmitted(name, resolved);
+        return this.fonts.getFont(name, resolved);
+    }
+    // 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) {
+        const resolved = this.resolveCustomStyle(name, style);
+        if (!resolved)
+            return "";
+        this.ensureEmitted(name, resolved);
+        const key = this.customKey(name, resolved);
+        const ttf = this.customFonts.get(key);
+        const used = this.customFontEmit.get(key).used;
+        let hex = "";
+        for (const ch of text) {
+            const gid = ttf.getGlyphIndex(ch.codePointAt(0));
+            used.add(gid); // record the glyph so the subset keeps it
+            hex += gid.toString(16).padStart(4, "0").toUpperCase();
+        }
+        return hex;
+    }
+    // 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);
+        // /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 ` +
+            `/FontBBox [${x0} ${y0} ${x1} ${y1}] /ItalicAngle 0 ` +
+            `/Ascent ${ttf.ascent} /Descent ${ttf.descent} /CapHeight ${ttf.ascent} /StemV 80 ` +
+            `/FontFile2 ${fontFile} 0 R >>`);
+    }
+    // CIDToGIDMap /Identity means CID == GID. /W lists only the USED glyphs' widths (sparse, one
+    // `gid [w]` entry each); everything else falls back to /DW.
+    buildCIDFont(name, ttf, descriptor, used) {
+        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}]`; })
+            .join(" ");
+        return (`<< /Type /Font /Subtype /CIDFontType2 /BaseFont /${name} ` +
+            `/CIDSystemInfo << /Registry (Adobe) /Ordering (Identity) /Supplement 0 >> ` +
+            `/FontDescriptor ${descriptor} 0 R /CIDToGIDMap /Identity ` +
+            `/DW 1000 /W [${w}] >>`);
+    }
+    // Maps glyph id -> Unicode so the text stays copy-/searchable (rendering doesn't need it). Only
+    // the used glyphs are listed, to match the subset.
+    buildToUnicode(ttf, used) {
+        const hex4 = (n) => n.toString(16).padStart(4, "0").toUpperCase();
+        const rev = ttf.reverseCmap();
+        const entries = [...used]
+            .sort((a, b) => a - b)
+            .filter((g) => rev.has(g))
+            .map((g) => [g, rev.get(g)]);
+        const blocks = [];
+        for (let i = 0; i < entries.length; i += 100) {
+            const block = entries.slice(i, i + 100);
+            const lines = block.map(([gid, code]) => `<${hex4(gid)}> <${hex4(code)}>`);
+            blocks.push(`${block.length} beginbfchar\n${lines.join("\n")}\nendbfchar`);
+        }
+        const body = `/CIDInit /ProcSet findresource begin\n12 dict begin\nbegincmap\n` +
+            `/CIDSystemInfo << /Registry (Adobe) /Ordering (UCS) /Supplement 0 >> def\n` +
+            `/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"));
+    }
+    buildType0(name, cidFont, toUnicode) {
+        return (`<< /Type /Font /Subtype /Type0 /BaseFont /${name} /Encoding /Identity-H ` +
+            `/DescendantFonts [${cidFont} 0 R] /ToUnicode ${toUnicode} 0 R >>`);
+    }
+    // Returns the current width of a text, included kernings
+    getStringWidth(text, fontFamily, fontSize, fontStyle) {
+        let width = 0;
+        // We must calculate each sign
+        for (let i = 0; i < text.length; i++) {
+            const char = text[i];
+            const nextChar = text[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
+            }
+        }
+        return width;
+    }
+    getCharCode(char) {
+        return char.charCodeAt(0).toString();
+    }
+    getAVMParserByFont(fullFontName, fontName, fontStyle) {
+        if (!fullFontName && (!fontName || !fontStyle)) {
+            throw new Error("No font family is given. Please set a full font name or a font with font style");
+        }
+        let result;
+        if (fullFontName) {
+            result = this.afmParsers.find((f) => f.fullFontName === fullFontName);
+        }
+        else {
+            result = this.afmParsers.find((f) => f.fontName === fontName && f.fontStyle === fontStyle);
+        }
+        if (!result)
+            throw new Error(`Cannot find a parser for the given font family ${fullFontName || fontName || "No given font"}`);
+        return result;
+    }
+    // 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);
+        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"
+        if (!advanceWidth) {
+            throw new Error(`Kein Metrik-Eintrag für Zeichen: ${char} ${this.getCharCode(char)}`);
+        }
+        // Width of the character multiplied by the font size (scaled proportionally)
+        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 !== null && fullFontName !== void 0 ? 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();
+    }
+    // Returns all images
+    getAllImagesRaw() {
+        return this.images.getAllImages();
+    }
+    // Returns all rendered objects as a string
+    getRenderedObjects() {
+        let result = "";
+        this.objectPositions = [];
+        this.objects.forEach((content, index) => {
+            const position = result.length + this.getHeader().length; // Calculate positions after the header
+            this.objectPositions.push(position);
+            result += `${index + 1} 0 obj\n${content}\nendobj\n`;
+        });
+        return result;
+    }
+    // Creates the cross-reference table
+    getXRefTable() {
+        let xref = "xref\n";
+        xref += `0 ${this.objects.length + 1}\n`;
+        xref += `0000000000 65535 f \n`; // Free object
+        this.objectPositions.forEach((pos) => {
+            xref += `${pos.toString().padStart(10, "0")} 00000 n \n`;
+        });
+        return xref;
+    }
+    // Calculates the position of the XRef table and returns the trailer
+    getTrailerAndXRef(startxref) {
+        const objectCount = this.getObjectCount();
+        const root = this.objects.findIndex((f) => f.toLowerCase().includes("catalog")) + 1;
+        // A fresh document uses the same hash for both /ID strings; they only diverge on an update.
+        const id = this.documentId ? ` /ID [${this.contentId()} ${this.contentId()}]` : "";
+        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()}>`;
+    }
+    // Returns the number of objects
+    getObjectCount() {
+        return this.objects.length;
+    }
+}
+exports.PDFObjectManager = PDFObjectManager;

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

@@ -0,0 +1,6 @@
+export declare class RendererRegistry {
+    private static renderers;
+    static register(elementClass: Function, renderer: Function): void;
+    static getRenderer(element: object): Function | undefined;
+    static isRendererAsync(renderer: Function): boolean;
+}

package/dist/utils/renderer-registry.js

@@ -0,0 +1,19 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.RendererRegistry = void 0;
+class RendererRegistry {
+    static register(elementClass, renderer) {
+        if (!RendererRegistry.renderers.has(elementClass)) {
+            RendererRegistry.renderers.set(elementClass, renderer);
+        }
+    }
+    // Keyed on the element's constructor, so it only needs an object - not `any`.
+    static getRenderer(element) {
+        return RendererRegistry.renderers.get(element.constructor);
+    }
+    static isRendererAsync(renderer) {
+        return renderer.constructor.name === "AsyncFunction";
+    }
+}
+exports.RendererRegistry = RendererRegistry;
+RendererRegistry.renderers = new Map();