@polotno/pdf-import 0.0.1

package/README.md

@@ -0,0 +1,39 @@
+# Polotno PDF Import
+
+Convert PDF files into [Polotno](https://polotno.com/) JSON format.
+
+For full documentation and demo, see [PDF Import Guide](https://polotno.com/docs/pdf-import).
+
+## Installation
+
+```bash
+npm install @polotno/pdf-import
+```
+
+## Usage
+
+### Node.js
+
+```ts
+import fs from 'fs';
+import { pdfToJson } from '@polotno/pdf-import';
+
+const pdfBuffer = fs.readFileSync('document.pdf');
+const json = await pdfToJson({ pdf: pdfBuffer });
+console.log(json);
+// { width: 612, height: 792, pages: [{ id: '...', children: [] }] }
+```
+
+### Browser
+
+```ts
+import { pdfToJson } from '@polotno/pdf-import';
+
+const input = document.querySelector('input[type="file"]');
+input.addEventListener('change', async (e) => {
+  const file = e.target.files[0];
+  const pdfBuffer = await file.arrayBuffer();
+  const json = await pdfToJson({ pdf: pdfBuffer });
+  console.log(json);
+});
+```

package/lib/color-utils.d.ts

@@ -0,0 +1,2 @@
+export declare function rgbTupleToHex(r: number, g: number, b: number): string;
+//# sourceMappingURL=color-utils.d.ts.map

package/lib/color-utils.js

@@ -0,0 +1,10 @@
+export function rgbTupleToHex(r, g, b) {
+    const ri = Math.max(0, Math.min(255, Math.round(r * 255)));
+    const gi = Math.max(0, Math.min(255, Math.round(g * 255)));
+    const bi = Math.max(0, Math.min(255, Math.round(b * 255)));
+    return ('#' +
+        ri.toString(16).toUpperCase().padStart(2, '0') +
+        gi.toString(16).toUpperCase().padStart(2, '0') +
+        bi.toString(16).toUpperCase().padStart(2, '0'));
+}
+//# sourceMappingURL=color-utils.js.map

package/lib/constants.d.ts

@@ -0,0 +1,13 @@
+export declare const PDF_TO_WEB_FONT_MAP: Record<string, string>;
+export declare const DEFAULT_FONT_FAMILY = "Roboto";
+export declare const DEFAULT_FONT_SIZE = 14;
+export declare const DEFAULT_FILL = "#000000";
+export declare const DEFAULT_BACKGROUND = "#FFFFFF";
+export declare const DEFAULT_LINE_HEIGHT = 1.2;
+export declare const DEFAULT_LETTER_SPACING = 0;
+export declare const MIN_TEXT_WIDTH = 2;
+export declare const MIN_TEXT_HEIGHT = 2;
+export declare const MIN_IMAGE_WIDTH = 5;
+export declare const MIN_IMAGE_HEIGHT = 5;
+export declare const MIN_FONT_SIZE = 4;
+//# sourceMappingURL=constants.d.ts.map

package/lib/constants.js

@@ -0,0 +1,111 @@
+export const PDF_TO_WEB_FONT_MAP = {
+    // Arial family
+    arial: 'Arial',
+    arialmt: 'Arial',
+    'arial-boldmt': 'Arial',
+    'arial-italicmt': 'Arial',
+    'arial-bolditalicmt': 'Arial',
+    arialmtbold: 'Arial',
+    // Helvetica family
+    helvetica: 'Helvetica',
+    'helvetica-bold': 'Helvetica',
+    'helvetica-oblique': 'Helvetica',
+    'helvetica-boldoblique': 'Helvetica',
+    helveticaneue: 'Helvetica Neue',
+    'helveticaneue-bold': 'Helvetica Neue',
+    'helveticaneue-light': 'Helvetica Neue',
+    // Times family
+    times: 'Times New Roman',
+    timesnewroman: 'Times New Roman',
+    timesnewromanpsmt: 'Times New Roman',
+    'timesnewromanps-boldmt': 'Times New Roman',
+    'timesnewromanps-italicmt': 'Times New Roman',
+    'times-roman': 'Times New Roman',
+    'times-bold': 'Times New Roman',
+    'times-italic': 'Times New Roman',
+    // Courier family
+    courier: 'Courier New',
+    couriernew: 'Courier New',
+    couriernewpsmt: 'Courier New',
+    'courier-bold': 'Courier New',
+    // Georgia
+    georgia: 'Georgia',
+    'georgia-bold': 'Georgia',
+    // Verdana
+    verdana: 'Verdana',
+    'verdana-bold': 'Verdana',
+    // Calibri family
+    calibri: 'Calibri',
+    'calibri-bold': 'Calibri',
+    'calibri-italic': 'Calibri',
+    'calibri-light': 'Calibri',
+    // Cambria
+    cambria: 'Cambria',
+    cambriamath: 'Cambria',
+    // Open Sans
+    opensans: 'Open Sans',
+    'opensans-regular': 'Open Sans',
+    'opensans-bold': 'Open Sans',
+    'opensans-light': 'Open Sans',
+    'opensans-semibold': 'Open Sans',
+    // Roboto
+    roboto: 'Roboto',
+    'roboto-regular': 'Roboto',
+    'roboto-bold': 'Roboto',
+    'roboto-light': 'Roboto',
+    'roboto-medium': 'Roboto',
+    // Roboto Condensed
+    robotocondensed: 'Roboto Condensed',
+    'robotocondensed-regular': 'Roboto Condensed',
+    'robotocondensed-bold': 'Roboto Condensed',
+    'robotocondensed-light': 'Roboto Condensed',
+    'robotocondensed-italic': 'Roboto Condensed',
+    // Lato
+    lato: 'Lato',
+    'lato-regular': 'Lato',
+    'lato-bold': 'Lato',
+    // Montserrat
+    montserrat: 'Montserrat',
+    'montserrat-bold': 'Montserrat',
+    // PT fonts
+    ptserif: 'PT Serif',
+    'ptserif-regular': 'PT Serif',
+    'ptserif-bold': 'PT Serif',
+    'ptserif-italic': 'PT Serif',
+    'ptserif-bolditalic': 'PT Serif',
+    ptsans: 'PT Sans',
+    'ptsans-regular': 'PT Sans',
+    'ptsans-bold': 'PT Sans',
+    // Noto Sans
+    notosans: 'Noto Sans',
+    'notosans-regular': 'Noto Sans',
+    'notosans-bold': 'Noto Sans',
+    'notosans-italic': 'Noto Sans',
+    // Poppins
+    poppins: 'Poppins',
+    'poppins-regular': 'Poppins',
+    'poppins-bold': 'Poppins',
+    'poppins-italic': 'Poppins',
+    'poppins-light': 'Poppins',
+    'poppins-medium': 'Poppins',
+    'poppins-semibold': 'Poppins',
+    // League Spartan
+    leaguespartan: 'League Spartan',
+    'leaguespartan-bold': 'League Spartan',
+    // Symbol / special
+    symbol: 'Symbol',
+    zapfdingbats: 'ZapfDingbats',
+    wingdings: 'Wingdings',
+};
+export const DEFAULT_FONT_FAMILY = 'Roboto';
+export const DEFAULT_FONT_SIZE = 14;
+export const DEFAULT_FILL = '#000000';
+export const DEFAULT_BACKGROUND = '#FFFFFF';
+export const DEFAULT_LINE_HEIGHT = 1.2;
+export const DEFAULT_LETTER_SPACING = 0;
+export const MIN_TEXT_WIDTH = 2;
+export const MIN_TEXT_HEIGHT = 2;
+export const MIN_IMAGE_WIDTH = 5;
+export const MIN_IMAGE_HEIGHT = 5;
+export const MIN_FONT_SIZE = 4.0;
+//# sourceMappingURL=constants.js.map

package/lib/font-mapper.d.ts

@@ -0,0 +1,7 @@
+export declare function cleanPdfFontName(rawName: string): string;
+export declare function extractWeightFromName(rawName: string): string;
+export declare function extractStyleFromName(rawName: string): string;
+export declare function mapPdfFont(rawName: string): string;
+/** Check if a PDF font name maps to a known web/Google font in our lookup table. */
+export declare function isKnownWebFont(rawName: string): boolean;
+//# sourceMappingURL=font-mapper.d.ts.map

package/lib/font-mapper.js

@@ -0,0 +1,111 @@
+import { PDF_TO_WEB_FONT_MAP } from './constants.js';
+export function cleanPdfFontName(rawName) {
+    return rawName
+        .replace(/^[A-Z]{6}\+/, '')
+        .replace(/_\d+wght$/i, '') // Google Fonts variable font naming: Arimo_700wght → Arimo
+        .toLowerCase()
+        .trim();
+}
+export function extractWeightFromName(rawName) {
+    const lower = rawName.toLowerCase();
+    // Google Fonts variable font naming: Arimo_700wght
+    const wghtMatch = lower.match(/_(\d+)wght/);
+    if (wghtMatch) {
+        const w = parseInt(wghtMatch[1], 10);
+        if (w >= 600)
+            return 'bold';
+        if (w <= 300)
+            return 'light';
+        return 'normal';
+    }
+    if (['bold', 'heavy', 'black', 'semibold', 'demibold'].some((w) => lower.includes(w))) {
+        return 'bold';
+    }
+    if (['light', 'thin', 'extralight', 'ultralight'].some((w) => lower.includes(w))) {
+        return 'light';
+    }
+    return 'normal';
+}
+export function extractStyleFromName(rawName) {
+    const lower = rawName.toLowerCase();
+    if (['italic', 'oblique', 'inclined'].some((s) => lower.includes(s))) {
+        return 'italic';
+    }
+    return 'normal';
+}
+function removeSuffix(str, suffix) {
+    if (str.endsWith(suffix)) {
+        return str.slice(0, -suffix.length);
+    }
+    return str;
+}
+function lookupKnownWebFont(rawName) {
+    const cleaned = cleanPdfFontName(rawName);
+    // 1. Exact match
+    if (cleaned in PDF_TO_WEB_FONT_MAP) {
+        return PDF_TO_WEB_FONT_MAP[cleaned];
+    }
+    // 2. Try removing common suffixes
+    for (const suffix of [
+        '-roman',
+        'psmt',
+        'ps-boldmt',
+        'ps-italicmt',
+        'ps-bolditalicmt',
+        'mt',
+        'ps',
+    ]) {
+        const base = removeSuffix(cleaned, suffix);
+        if (base !== cleaned && base in PDF_TO_WEB_FONT_MAP) {
+            return PDF_TO_WEB_FONT_MAP[base];
+        }
+    }
+    // 3. Try removing weight/style suffixes
+    for (const suffix of [
+        '-bolditalic',
+        '-boldoblique',
+        '-bold',
+        '-italic',
+        '-oblique',
+        '-light',
+        '-regular',
+        '-medium',
+        '-semibold',
+        '-thin',
+        '-heavy',
+    ]) {
+        const base = removeSuffix(cleaned, suffix);
+        if (base !== cleaned && base in PDF_TO_WEB_FONT_MAP) {
+            return PDF_TO_WEB_FONT_MAP[base];
+        }
+    }
+    // 4. Check if any known family name is a substring (longest key first)
+    const sortedEntries = Object.entries(PDF_TO_WEB_FONT_MAP).sort((a, b) => b[0].length - a[0].length);
+    for (const [pdfKey, webFont] of sortedEntries) {
+        if (cleaned.includes(pdfKey) || pdfKey.includes(cleaned)) {
+            return webFont;
+        }
+    }
+    return null;
+}
+export function mapPdfFont(rawName) {
+    const matched = lookupKnownWebFont(rawName);
+    if (matched) {
+        return matched;
+    }
+    // 5. Return cleaned name as-is (might be valid custom font)
+    let displayName = rawName.replace(/^[A-Z]{6}\+/, '');
+    displayName = displayName
+        .replace(/_\d+wght$/i, '') // Google Fonts variable font naming
+        .replace(/[-](Bold|Italic|Regular|Light|Medium|Thin|Heavy|BoldItalic|Oblique|BoldOblique)(MT|PSMT|PS)?$/i, '');
+    if (displayName && displayName.length > 2) {
+        const spaced = displayName.replace(/(?<=[a-z])(?=[A-Z])/g, ' ');
+        return spaced;
+    }
+    return rawName;
+}
+/** Check if a PDF font name maps to a known web/Google font in our lookup table. */
+export function isKnownWebFont(rawName) {
+    return lookupKnownWebFont(rawName) !== null;
+}
+//# sourceMappingURL=font-mapper.js.map

package/lib/font-matcher.d.ts

@@ -0,0 +1,10 @@
+export interface FontMetrics {
+    fontName: string;
+    isSerifFont: boolean;
+    isMonospace: boolean;
+    avgWidth: number;
+    ascent: number;
+    descent: number;
+}
+export declare function findClosestGoogleFont(metrics: FontMetrics): string;
+//# sourceMappingURL=font-matcher.d.ts.map

package/lib/font-matcher.js

@@ -0,0 +1,89 @@
+// Google Font matching for non-embeddable PDF fonts.
+// Uses font metrics (average glyph width, ascent/descent) and name hints
+// to find the closest matching Google Font.
+// Reference metrics for popular Google Fonts.
+// avgWidth = average glyph width in 1/1000 em units (measured from font files).
+// These are approximate but good enough for nearest-neighbor matching.
+const GOOGLE_FONT_TABLE = [
+    // Sans-serif — narrow/condensed
+    { name: 'Roboto Condensed', category: 'sans-serif', avgWidth: 460, ascent: 0.928, descent: -0.244 },
+    { name: 'Barlow Condensed', category: 'sans-serif', avgWidth: 420, ascent: 0.950, descent: -0.250 },
+    // Sans-serif — normal width
+    { name: 'Roboto', category: 'sans-serif', avgWidth: 538, ascent: 0.928, descent: -0.244 },
+    { name: 'Open Sans', category: 'sans-serif', avgWidth: 570, ascent: 1.069, descent: -0.293 },
+    { name: 'Lato', category: 'sans-serif', avgWidth: 518, ascent: 0.987, descent: -0.213 },
+    { name: 'Inter', category: 'sans-serif', avgWidth: 540, ascent: 0.984, descent: -0.250 },
+    { name: 'DM Sans', category: 'sans-serif', avgWidth: 530, ascent: 1.000, descent: -0.250 },
+    { name: 'Work Sans', category: 'sans-serif', avgWidth: 535, ascent: 0.970, descent: -0.260 },
+    { name: 'Outfit', category: 'sans-serif', avgWidth: 530, ascent: 1.000, descent: -0.260 },
+    { name: 'Noto Sans', category: 'sans-serif', avgWidth: 545, ascent: 1.069, descent: -0.293 },
+    { name: 'PT Sans', category: 'sans-serif', avgWidth: 510, ascent: 0.905, descent: -0.212 },
+    { name: 'Source Sans Pro', category: 'sans-serif', avgWidth: 500, ascent: 0.984, descent: -0.273 },
+    // Sans-serif — wide/geometric
+    { name: 'Montserrat', category: 'sans-serif', avgWidth: 640, ascent: 0.968, descent: -0.251 },
+    { name: 'Poppins', category: 'sans-serif', avgWidth: 540, ascent: 1.050, descent: -0.350 },
+    { name: 'Nunito', category: 'sans-serif', avgWidth: 580, ascent: 1.011, descent: -0.353 },
+    { name: 'Raleway', category: 'sans-serif', avgWidth: 600, ascent: 0.930, descent: -0.250 },
+    { name: 'Nunito Sans', category: 'sans-serif', avgWidth: 545, ascent: 1.011, descent: -0.353 },
+    { name: 'Manrope', category: 'sans-serif', avgWidth: 560, ascent: 1.028, descent: -0.272 },
+    // Serif
+    { name: 'Merriweather', category: 'serif', avgWidth: 530, ascent: 0.985, descent: -0.300 },
+    { name: 'Lora', category: 'serif', avgWidth: 510, ascent: 0.956, descent: -0.382 },
+    { name: 'PT Serif', category: 'serif', avgWidth: 524, ascent: 1.039, descent: -0.286 },
+    { name: 'Noto Serif', category: 'serif', avgWidth: 530, ascent: 1.069, descent: -0.293 },
+    { name: 'Source Serif Pro', category: 'serif', avgWidth: 505, ascent: 0.918, descent: -0.250 },
+    { name: 'Libre Baskerville', category: 'serif', avgWidth: 540, ascent: 0.983, descent: -0.300 },
+    { name: 'Playfair Display', category: 'serif', avgWidth: 500, ascent: 1.082, descent: -0.251 },
+    { name: 'EB Garamond', category: 'serif', avgWidth: 440, ascent: 0.960, descent: -0.240 },
+    { name: 'Crimson Text', category: 'serif', avgWidth: 460, ascent: 0.927, descent: -0.315 },
+    // Monospace
+    { name: 'Roboto Mono', category: 'monospace', avgWidth: 600, ascent: 1.048, descent: -0.271 },
+    { name: 'Source Code Pro', category: 'monospace', avgWidth: 600, ascent: 0.984, descent: -0.273 },
+    { name: 'JetBrains Mono', category: 'monospace', avgWidth: 600, ascent: 1.020, descent: -0.300 },
+    { name: 'Fira Code', category: 'monospace', avgWidth: 600, ascent: 0.935, descent: -0.265 },
+    // Script/handwriting
+    { name: 'Dancing Script', category: 'script', avgWidth: 470, ascent: 0.958, descent: -0.400 },
+    { name: 'Great Vibes', category: 'script', avgWidth: 430, ascent: 1.050, descent: -0.550 },
+    { name: 'Pacifico', category: 'script', avgWidth: 550, ascent: 1.050, descent: -0.370 },
+    { name: 'Sacramento', category: 'script', avgWidth: 380, ascent: 0.900, descent: -0.400 },
+    { name: 'Satisfy', category: 'script', avgWidth: 460, ascent: 1.050, descent: -0.350 },
+];
+// Keywords in font names that hint at category
+const SERIF_HINTS = ['serif', 'roman', 'garamond', 'baskerville', 'palatino', 'georgia', 'cambria', 'minion', 'caslon', 'bodoni', 'didot', 'times', 'book'];
+const MONO_HINTS = ['mono', 'courier', 'consolas', 'code', 'terminal', 'fixed'];
+const SCRIPT_HINTS = ['script', 'cursive', 'handwrit', 'callig', 'brush', 'sloop', 'dancing', 'pacifico', 'satisfy', 'lobster', 'sacramento', 'kaushan'];
+function detectCategory(metrics) {
+    const lower = metrics.fontName.toLowerCase();
+    if (SCRIPT_HINTS.some(h => lower.includes(h)))
+        return 'script';
+    if (metrics.isMonospace || MONO_HINTS.some(h => lower.includes(h)))
+        return 'monospace';
+    if (metrics.isSerifFont || SERIF_HINTS.some(h => lower.includes(h)))
+        return 'serif';
+    return 'sans-serif';
+}
+export function findClosestGoogleFont(metrics) {
+    const category = detectCategory(metrics);
+    // Filter candidates by category
+    let candidates = GOOGLE_FONT_TABLE.filter(f => f.category === category);
+    if (candidates.length === 0) {
+        // Fallback to all sans-serif if category has no entries
+        candidates = GOOGLE_FONT_TABLE.filter(f => f.category === 'sans-serif');
+    }
+    // Score each candidate: lower is better
+    // Weight width similarity most heavily since it's the most visually impactful
+    let best = candidates[0];
+    let bestScore = Infinity;
+    for (const candidate of candidates) {
+        const widthDiff = Math.abs(candidate.avgWidth - metrics.avgWidth) / 100;
+        const ascentDiff = Math.abs(candidate.ascent - metrics.ascent) * 2;
+        const descentDiff = Math.abs(candidate.descent - metrics.descent) * 2;
+        const score = widthDiff + ascentDiff + descentDiff;
+        if (score < bestScore) {
+            bestScore = score;
+            best = candidate;
+        }
+    }
+    return best.name;
+}
+//# sourceMappingURL=font-matcher.js.map

package/lib/font-merger.d.ts

@@ -0,0 +1,7 @@
+/**
+ * Merge multiple font subset buffers into a single font.
+ * Deduplicates glyphs by unicode code point, keeping the first occurrence.
+ * Falls back to the largest blob if merging fails.
+ */
+export declare function mergeSubsetFonts(buffers: Uint8Array[]): Uint8Array;
+//# sourceMappingURL=font-merger.d.ts.map

package/lib/font-merger.js

@@ -0,0 +1,114 @@
+import opentype from 'opentype.js';
+// Unicode Private Use Area range added by pdfjs for internal glyph mapping.
+// These must be stripped before merging to avoid cmap conflicts.
+const PUA_START = 0xe000;
+const PUA_END = 0xf8ff;
+function isPUA(u) {
+    return u >= PUA_START && u <= PUA_END;
+}
+/**
+ * Merge multiple font subset buffers into a single font.
+ * Deduplicates glyphs by unicode code point, keeping the first occurrence.
+ * Falls back to the largest blob if merging fails.
+ */
+export function mergeSubsetFonts(buffers) {
+    if (buffers.length === 1)
+        return buffers[0];
+    try {
+        // Start with the largest subset as the base
+        const sorted = [...buffers].sort((a, b) => b.length - a.length);
+        const base = opentype.parse(toArrayBuffer(sorted[0]));
+        // Strip PUA unicodes from base font glyphs
+        stripPUA(base);
+        // Collect existing unicodes from base font
+        const existingUnicodes = new Set();
+        for (let i = 0; i < base.glyphs.length; i++) {
+            const g = base.glyphs.get(i);
+            if (g.unicodes)
+                g.unicodes.forEach((u) => existingUnicodes.add(u));
+        }
+        // Merge glyphs from remaining subsets
+        for (let si = 1; si < sorted.length; si++) {
+            const other = opentype.parse(toArrayBuffer(sorted[si]));
+            stripPUA(other);
+            for (let i = 0; i < other.glyphs.length; i++) {
+                const g = other.glyphs.get(i);
+                const unis = g.unicodes || [];
+                if (unis.length === 0)
+                    continue;
+                if (unis.every((u) => existingUnicodes.has(u)))
+                    continue;
+                base.glyphs.push(base.glyphs.length, g);
+                unis.forEach((u) => existingUnicodes.add(u));
+            }
+        }
+        // Assign names to unnamed glyphs to avoid opentype.js warnings
+        assignMissingGlyphNames(base);
+        // Assign a non-zero createdTimestamp so opentype.js doesn't generate a fresh
+        // one on each serialization (it checks `if (options.createdTimestamp)`).
+        base.createdTimestamp = 1;
+        const merged = base.toArrayBuffer();
+        // opentype.js writes non-deterministic fields (modified timestamp, checksums)
+        // into the serialized font. Zero them out for stable output.
+        stabilizeFontBytes(new Uint8Array(merged));
+        return new Uint8Array(merged);
+    }
+    catch {
+        // Fall back to largest blob if parsing/merging fails
+        return buffers.reduce((a, b) => (a.length >= b.length ? a : b));
+    }
+}
+function stripPUA(font) {
+    for (let i = 0; i < font.glyphs.length; i++) {
+        const g = font.glyphs.get(i);
+        if (g.unicodes) {
+            g.unicodes = g.unicodes.filter((u) => !isPUA(u));
+        }
+        if (g.unicode && isPUA(g.unicode)) {
+            g.unicode = g.unicodes.length > 0 ? g.unicodes[0] : 0;
+        }
+    }
+}
+function assignMissingGlyphNames(font) {
+    for (let i = 0; i < font.glyphs.length; i++) {
+        const g = font.glyphs.get(i);
+        if (!g.name) {
+            g.name = g.unicode ? `uni${g.unicode.toString(16).toUpperCase().padStart(4, '0')}` : `glyph${i}`;
+        }
+    }
+}
+/**
+ * Zero out non-deterministic fields in the serialized font so output is stable
+ * across runs. opentype.js writes a current-time "modified" timestamp and
+ * computes checksums that vary slightly between processes.
+ *
+ * Fields zeroed in the head table (found via the table directory):
+ *  - checkSumAdjustment (offset 8, 4 bytes) — whole-file checksum
+ *  - modified           (offset 28, 8 bytes) — current-time timestamp
+ * Also zeroes the head entry's checksum in the table directory (offset 4, 4 bytes).
+ */
+function stabilizeFontBytes(buf) {
+    const view = new DataView(buf.buffer, buf.byteOffset, buf.byteLength);
+    const numTables = view.getUint16(4);
+    for (let i = 0; i < numTables; i++) {
+        const dirOffset = 12 + i * 16;
+        const tag = String.fromCharCode(buf[dirOffset], buf[dirOffset + 1], buf[dirOffset + 2], buf[dirOffset + 3]);
+        if (tag === 'head') {
+            const tableOffset = view.getUint32(dirOffset + 8);
+            // Zero head directory checksum (4 bytes at dirOffset+4)
+            for (let b = 0; b < 4; b++)
+                buf[dirOffset + 4 + b] = 0;
+            // Zero checkSumAdjustment (4 bytes at head+8)
+            for (let b = 0; b < 4; b++)
+                buf[tableOffset + 8 + b] = 0;
+            // Zero modified timestamp (8 bytes at head+28)
+            for (let b = 0; b < 8; b++)
+                buf[tableOffset + 28 + b] = 0;
+            return;
+        }
+    }
+}
+function toArrayBuffer(data) {
+    return data.buffer.slice(data.byteOffset, data.byteOffset + data.byteLength);
+}
+//# sourceMappingURL=font-merger.js.map

package/lib/font-registry.d.ts

@@ -0,0 +1,15 @@
+import opentype from 'opentype.js';
+import type { PolotnoFont, PolotnoPage } from './index.js';
+export declare class FontRegistry {
+    private fontDataMap;
+    private fontMetricsMap;
+    private otCache;
+    /**
+     * Parse font data with opentype.js, returning cached result if available.
+     * Key is the pdfjs loaded font name (e.g. "g_d0_f1").
+     */
+    parseOpentype(loadedName: string, data: Uint8Array): opentype.Font | null;
+    recordFont(fontObj: any): void;
+    finalize(fontStrategy: 'embed' | 'googleFontsMatch', pages: PolotnoPage[]): PolotnoFont[];
+}
+//# sourceMappingURL=font-registry.d.ts.map

package/lib/font-registry.js

@@ -0,0 +1,110 @@
+import opentype from 'opentype.js';
+import { mapPdfFont, isKnownWebFont } from './font-mapper.js';
+import { findClosestGoogleFont } from './font-matcher.js';
+import { mergeSubsetFonts } from './font-merger.js';
+export class FontRegistry {
+    constructor() {
+        this.fontDataMap = new Map();
+        this.fontMetricsMap = new Map();
+        // Cache opentype.js parsed fonts across pages to avoid re-parsing
+        this.otCache = new Map();
+    }
+    /**
+     * Parse font data with opentype.js, returning cached result if available.
+     * Key is the pdfjs loaded font name (e.g. "g_d0_f1").
+     */
+    parseOpentype(loadedName, data) {
+        if (this.otCache.has(loadedName)) {
+            return this.otCache.get(loadedName);
+        }
+        try {
+            const buf = new Uint8Array(data).buffer;
+            const otFont = opentype.parse(buf);
+            this.otCache.set(loadedName, otFont);
+            return otFont;
+        }
+        catch {
+            this.otCache.set(loadedName, null);
+            return null;
+        }
+    }
+    recordFont(fontObj) {
+        if (!fontObj?.name)
+            return;
+        const mappedFamily = mapPdfFont(fontObj.name);
+        const isUnknown = !isKnownWebFont(fontObj.name);
+        // Collect font binary data for non-Google/non-standard fonts
+        if (isUnknown && fontObj.data && fontObj.data.length > 0) {
+            const mime = fontObj.mimetype || 'font/opentype';
+            const arr = this.fontDataMap.get(mappedFamily) || [];
+            arr.push({ mime, data: new Uint8Array(fontObj.data) });
+            this.fontDataMap.set(mappedFamily, arr);
+        }
+        // Collect font metrics for unknown fonts (for Google Font matching)
+        if (isUnknown && !this.fontMetricsMap.has(mappedFamily)) {
+            const widths = (fontObj.widths || []).filter((w) => w != null && w > 0);
+            const avgWidth = widths.length > 0
+                ? widths.reduce((a, b) => a + b, 0) / widths.length
+                : 500;
+            this.fontMetricsMap.set(mappedFamily, {
+                fontName: fontObj.name.replace(/^[A-Z]{6}\+/, ''),
+                isSerifFont: fontObj.isSerifFont || false,
+                isMonospace: fontObj.isMonospace || false,
+                avgWidth: Math.round(avgWidth),
+                ascent: fontObj.ascent || 0.9,
+                descent: fontObj.descent || -0.25,
+            });
+        }
+    }
+    finalize(fontStrategy, pages) {
+        const fonts = [];
+        if (fontStrategy === 'googleFontsMatch') {
+            // Replace all non-Google font families with closest Google Font matches
+            const fontReplacementMap = new Map();
+            for (const [mappedFamily, metrics] of this.fontMetricsMap) {
+                const googleFont = findClosestGoogleFont(metrics);
+                fontReplacementMap.set(mappedFamily, googleFont);
+            }
+            // Apply replacements to all text elements across all pages
+            for (const page of pages) {
+                for (const child of page.children) {
+                    if (child.type === 'text') {
+                        const replacement = fontReplacementMap.get(child.fontFamily);
+                        if (replacement) {
+                            child.fontFamily = replacement;
+                        }
+                    }
+                }
+            }
+            return fonts;
+        }
+        // 'embed' strategy: embed font data as base64 data URIs.
+        // When multiple subsets exist, merge them into a single font.
+        for (const [fontFamily, blobs] of this.fontDataMap) {
+            let fontData;
+            let mime;
+            if (blobs.length === 1) {
+                fontData = blobs[0].data;
+                mime = blobs[0].mime;
+            }
+            else {
+                fontData = mergeSubsetFonts(blobs.map((b) => b.data));
+                mime = blobs[0].mime;
+            }
+            let b64;
+            if (typeof Buffer !== 'undefined') {
+                b64 = Buffer.from(fontData).toString('base64');
+            }
+            else {
+                let binary = '';
+                for (let bi = 0; bi < fontData.length; bi++) {
+                    binary += String.fromCharCode(fontData[bi]);
+                }
+                b64 = btoa(binary);
+            }
+            fonts.push({ fontFamily, url: `data:${mime};base64,${b64}` });
+        }
+        return fonts;
+    }
+}
+//# sourceMappingURL=font-registry.js.map

package/lib/image-encoder.d.ts

@@ -0,0 +1,3 @@
+export declare function imageDataToDataUri(data: Uint8ClampedArray, width: number, height: number, kind: number): string;
+export declare function imageBytesToDataUri(data: Uint8Array, mimeType: string): string;
+//# sourceMappingURL=image-encoder.d.ts.map