pagyra-js 0.0.13 → 0.0.15

package/dist/src/pdf/font/binary-writer.d.ts

@@ -0,0 +1,18 @@
+export declare class BinaryWriter {
+    private buffer;
+    private view;
+    private offset;
+    constructor(initialSize?: number);
+    ensureSize(size: number): void;
+    writeUint8(value: number): void;
+    writeInt8(value: number): void;
+    writeUint16(value: number): void;
+    writeInt16(value: number): void;
+    writeUint32(value: number): void;
+    writeInt32(value: number): void;
+    writeFixed(value: number): void;
+    writeString(value: string): void;
+    writeBytes(bytes: Uint8Array): void;
+    getData(): Uint8Array;
+    byteLength(): number;
+}

package/dist/src/pdf/font/binary-writer.js

@@ -0,0 +1,67 @@
+export class BinaryWriter {
+    constructor(initialSize = 1024) {
+        this.buffer = new Uint8Array(initialSize);
+        this.view = new DataView(this.buffer.buffer);
+        this.offset = 0;
+    }
+    ensureSize(size) {
+        if (this.offset + size > this.buffer.length) {
+            const newSize = Math.max(this.buffer.length * 2, this.offset + size);
+            const newBuffer = new Uint8Array(newSize);
+            newBuffer.set(this.buffer);
+            this.buffer = newBuffer;
+            this.view = new DataView(this.buffer.buffer);
+        }
+    }
+    writeUint8(value) {
+        this.ensureSize(1);
+        this.view.setUint8(this.offset, value);
+        this.offset += 1;
+    }
+    writeInt8(value) {
+        this.ensureSize(1);
+        this.view.setInt8(this.offset, value);
+        this.offset += 1;
+    }
+    writeUint16(value) {
+        this.ensureSize(2);
+        this.view.setUint16(this.offset, value, false);
+        this.offset += 2;
+    }
+    writeInt16(value) {
+        this.ensureSize(2);
+        this.view.setInt16(this.offset, value, false);
+        this.offset += 2;
+    }
+    writeUint32(value) {
+        this.ensureSize(4);
+        this.view.setUint32(this.offset, value, false);
+        this.offset += 4;
+    }
+    writeInt32(value) {
+        this.ensureSize(4);
+        this.view.setInt32(this.offset, value, false);
+        this.offset += 4;
+    }
+    writeFixed(value) {
+        const integer = Math.floor(value);
+        const fraction = Math.floor((value - integer) * 65536);
+        this.writeInt16(integer);
+        this.writeUint16(fraction);
+    }
+    writeString(value) {
+        const encoded = new TextEncoder().encode(value);
+        this.writeBytes(encoded);
+    }
+    writeBytes(bytes) {
+        this.ensureSize(bytes.length);
+        this.buffer.set(bytes, this.offset);
+        this.offset += bytes.length;
+    }
+    getData() {
+        return this.buffer.slice(0, this.offset);
+    }
+    byteLength() {
+        return this.offset;
+    }
+}

package/dist/src/pdf/font/builtin-fonts.browser.js

@@ -98,7 +98,7 @@ function computeBaseUrl() {
         return `${origin}assets/fonts/`;
     }
     try {
-        return new URL("../../assets/fonts/", import.meta.url).toString();
+        return new URL(/* @vite-ignore */ "../../assets/fonts/", import.meta.url).toString();
     }
     catch {
         return "/assets/fonts/";

package/dist/src/pdf/font/embedder.d.ts

@@ -18,6 +18,7 @@ export declare class FontEmbedder {
     initialize(): Promise<void>;
     ensureFont(familyStack: string[], fontWeight?: number, fontStyle?: string): EmbeddedFont | null;
     private embedFont;
+    private realizeFont;
     private createToUnicodeCMap;
     /**
      * Return parsed TTF metrics for a loaded face by name or family, or null if not available.

package/dist/src/pdf/font/embedder.js

@@ -87,6 +87,25 @@ export class FontEmbedder {
         const metrics = this.faceMetrics.get(face.name);
         if (!metrics)
             return null;
+        const fullFontData = new Uint8Array(face.data);
+        const resourceName = `F${this.embeddedFonts.size + 1}`;
+        let realizedRef;
+        const self = this;
+        const embedded = {
+            resourceName,
+            baseFont: face.name,
+            metrics,
+            subset: fullFontData,
+            get ref() {
+                if (!realizedRef) {
+                    realizedRef = self.realizeFont(face, metrics, resourceName);
+                }
+                return realizedRef;
+            }
+        };
+        return embedded;
+    }
+    realizeFont(face, metrics, resourceName) {
         const unitsPerEm = metrics.metrics.unitsPerEm;
         const scaleTo1000 = (v) => Math.round((v / unitsPerEm) * 1000);
         let fontBBox;
@@ -95,16 +114,9 @@ export class FontEmbedder {
             fontBBox = [scaleTo1000(hb[0]), scaleTo1000(hb[1]), scaleTo1000(hb[2]), scaleTo1000(hb[3])];
         }
         else {
-            // Fallback if headBBox is missing
             fontBBox = [-1000, -1000, 1000, 1000];
         }
-        // Register the font file stream
-        // We need the full font data here. In the initialize method we updated face.data
-        // but here we need to access it.
-        // Since we can't easily change the interface, we'll assume face.data is the source.
-        // If it was converted to TTF in initialize, face.data (casted) holds the TTF buffer.
         const fullFontData = new Uint8Array(face.data);
-        // FontFile2 streams require only /Length (PdfDocument adds it); avoid Type1-specific Length1 headers.
         const fontFileRef = this.doc.registerStream(fullFontData, {});
         const fontDescriptor = {
             Type: "/FontDescriptor",
@@ -120,10 +132,7 @@ export class FontEmbedder {
             FontFile2: fontFileRef
         };
         const fontDescriptorRef = this.doc.register(fontDescriptor);
-        // Compute DW and compressed W
         const { DW, W } = computeWidths(metrics);
-        // Create CID font dictionary (include DW)
-        // CID fonts must declare string-valued CIDSystemInfo entries per PDF spec.
         const cidFontDict = {
             Type: "/Font",
             Subtype: "/CIDFontType2",
@@ -136,15 +145,10 @@ export class FontEmbedder {
             FontDescriptor: fontDescriptorRef,
             DW,
             W,
-            // Rely on built-in Identity CIDToGID mapping to keep font dictionaries simple/compatible.
             CIDToGIDMap: "/Identity"
         };
         const cidFontRef = this.doc.register(cidFontDict);
-        // Create Unicode mapping (ToUnicode CMap)
         const toUnicodeRef = this.createToUnicodeCMap(metrics);
-        // Create Type0 font dictionary
-        // Per PDF spec, Type0 BaseFont should include the CMap suffix (e.g. "-Identity-H")
-        // to make the composite font name unambiguous for parsers/renderers.
         const type0Font = {
             Type: "/Font",
             Subtype: "/Type0",
@@ -153,14 +157,7 @@ export class FontEmbedder {
             DescendantFonts: [cidFontRef],
             ToUnicode: toUnicodeRef
         };
-        const fontRef = this.doc.register(type0Font);
-        return {
-            resourceName: `F${this.embeddedFonts.size + 1}`,
-            ref: fontRef,
-            baseFont: face.name,
-            metrics,
-            subset: fullFontData
-        };
+        return this.doc.register(type0Font);
     }
     createToUnicodeCMap(metrics, _uniqueUnicodes = []) {
         // Build inverse mapping gid -> unicode (pick first unicode when multiple map to same gid)

package/dist/src/pdf/font/font-registry.js

@@ -4,17 +4,6 @@ import { log } from "../../logging/debug.js";
 import { needsUnicode } from "../../text/text.js";
 import { fontWeightCacheKey, normalizeFontWeight } from "../../css/font-weight.js";
 import { parseFontFaces, parseFamilyList, isItalicStyle, normalizeToken, } from "../../css/font-face-parser.js";
-// import {
-//   BASE_FONT_ALIASES,
-//   GENERIC_FAMILIES,
-//   BASE14_FALLBACKS,
-//   BASE14_FAMILY_VARIANTS,
-//   BASE14_VARIANT_LOOKUP,
-//   detectBase14Family,
-//   classifyBase14Variant,
-//   type Base14Family,
-//   type Base14Variant,
-// } from "./font-config.js";
 import { applyWeightToBaseFont } from "./resolvers/weight-style-applicator.js";
 import { buildAliasedFamilyStack } from "./resolvers/family-resolver.js";
 import { resolveBaseFont } from "./resolvers/base-font-mapper.js";
@@ -23,20 +12,17 @@ import { SubsetResourceManager } from "./managers/subset-resource-manager.js";
 export function getBase14(family) {
     return { isBase14: true, baseName: family, name: family };
 }
-// Note: getFontForText needs access to doc and config, so we'll modify the signature
 export function getFontForText(_requestedFamily, text, _doc, _config) {
     if (needsUnicode(text)) {
-        // For now, use a simplified approach - we'll assume NotoSans-Regular is available
-        // In a full implementation, you'd initialize the embedder properly
         const fontName = "NotoSans-Regular";
         log("font", "info", "font-path", { base14: false, family: fontName, encoding: "Identity-H" });
         return { isBase14: false, name: fontName };
     }
-    const f = getBase14("Helvetica"); // fallback
+    const f = getBase14("Helvetica");
     log("font", "info", "font-path", { base14: true, family: f.baseName, encoding: "WinAnsi" });
     return f;
 }
-const DEFAULT_FONT = "Times New Roman"; // Use embedded TTF font instead of base14
+const DEFAULT_FONT = "Times New Roman";
 export class FontRegistry {
     constructor(doc, stylesheets) {
         this.doc = doc;
@@ -62,7 +48,7 @@ export class FontRegistry {
                 const resource = {
                     baseFont: embedded.baseFont,
                     resourceName: embedded.resourceName,
-                    ref: embedded.ref,
+                    get ref() { return embedded.ref; },
                     isBase14: false,
                     metrics: embedded.metrics,
                     embedded,
@@ -75,7 +61,6 @@ export class FontRegistry {
         this.fontResourceManager.setCached(familyKey, resolved);
         return resolved;
     }
-    // New method to get embedder reference
     getEmbedder() {
         return this.embedder;
     }
@@ -94,14 +79,12 @@ export class FontRegistry {
         }
         if (this.embedder && this.fontConfig) {
             const familyStack = buildAliasedFamilyStack(family, this.fontConfig?.defaultStack);
-            // Note: embedder.ensureFont is synchronous in its implementation (it uses pre-loaded data)
-            // even though the interface might not explicitly say so, we know it returns EmbeddedFont | null immediately.
             const embedded = this.embedder.ensureFont(familyStack, normalizedWeight, style);
             if (embedded) {
                 const resource = {
                     baseFont: embedded.baseFont,
                     resourceName: embedded.resourceName,
-                    ref: embedded.ref,
+                    get ref() { return embedded.ref; },
                     isBase14: false,
                     metrics: embedded.metrics,
                     embedded,
@@ -169,7 +152,6 @@ export function initFontSystem(doc, stylesheets) {
 }
 export async function ensureFontSubset(registry, run) {
     const font = await registry.ensureFontResource(run.fontFamily, run.fontWeight, run.fontStyle);
-    // === diagnóstico cirúrgico: caminho de fonte ===
     log("font", "info", "font-path", {
         base14: font.isBase14 === true,
         family: font.baseFont,
@@ -179,7 +161,6 @@ export async function ensureFontSubset(registry, run) {
 }
 export function ensureFontSubsetSync(registry, run) {
     const font = registry.ensureFontResourceSync(run.fontFamily, run.fontWeight, run.fontStyle);
-    // === diagnóstico cirúrgico: caminho de fonte ===
     log("font", "info", "font-path", {
         base14: font.isBase14 === true,
         family: font.baseFont,
@@ -188,8 +169,6 @@ export function ensureFontSubsetSync(registry, run) {
     return font;
 }
 export function finalizeFontSubsets(_registry) {
-    // Actual font materialization happens during PdfDocument.finalize().
 }
 export function preflightFontsForPdfa(_registry) {
-    // Placeholder for PDF/A validations.
 }

package/dist/src/pdf/font/font-subset.d.ts

@@ -11,10 +11,13 @@ export interface PdfFontSubset {
     fontFile: Uint8Array;
     encodeGlyph(gid: number): number;
     /**
-     * Ordered glyph IDs included in this subset. The position in this array matches
-     * the width entries when using identity encoding.
+     * Ordered glyph IDs included in this subset.
      */
     glyphIds: number[];
+    /**
+     * Map from original GID to new subset GID.
+     */
+    gidMap: Map<number, number>;
 }
 /**
  * Options for creating a PDF font subset.
@@ -26,8 +29,8 @@ export interface PdfFontSubsetOptions {
     usedGlyphIds: Set<number>;
     /**
      * Controls how glyph IDs are mapped to PDF character codes.
-     * - "identity" keeps CIDs = glyph IDs (suitable for CIDToGIDMap /Identity).
-     * - "sequential" densely re-encodes glyphs starting at 0.
+     * - "identity" keeps CIDs = Original Glyph IDs (most stable for progressive rendering).
+     * - "sequential" densely re-encodes glyphs starting at 0 (most compact).
      */
     encoding?: "identity" | "sequential";
 }