pdf-lite 1.5.0 → 1.6.1

package/dist/fonts/manager.js

@@ -1,378 +0,0 @@
-import { PdfDictionary } from '../core/objects/pdf-dictionary.js';
-import { PdfIndirectObject } from '../core/objects/pdf-indirect-object.js';
-import { PdfName } from '../core/objects/pdf-name.js';
-import { PdfArray } from '../core/objects/pdf-array.js';
-import { PdfObjectReference } from '../core/objects/pdf-object-reference.js';
-import { PdfFont } from './pdf-font.js';
-import { parseFont } from './parsers/font-parser.js';
-/**
- * Manages font embedding in PDF documents.
- * Provides methods to embed TrueType and other font formats.
- */
-export class PdfFontManager {
-    document;
-    fontResourceCounter = 0;
-    constructor(document) {
-        this.document = document;
-    }
-    async findFontByName(fontName) {
-        return await this.searchFontInPdf(fontName);
-    }
-    /**
-     * Embeds a TrueType font into the PDF document.
-     *
-     * @param fontData - The font file bytes
-     * @param fontName - The name to use for this font in the PDF
-     * @param descriptor - Font metrics and properties
-     * @returns A PdfFont object representing the embedded font
-     */
-    async embedTrueTypeFont(fontData, fontName, descriptor) {
-        // Create font using factory
-        const font = PdfFont.fromTrueTypeData(fontData, fontName, descriptor);
-        // Write to PDF
-        return await this.write(font);
-    }
-    /**
-     * Embeds a standard PDF font (Type1).
-     * These fonts don't require font data as they're built into PDF viewers.
-     *
-     * @param fontName - One of the 14 standard PDF fonts
-     * @returns A PdfFont object representing the embedded font
-     */
-    async embedStandardFont(fontName) {
-        // Create font using factory
-        const font = PdfFont.fromStandardFont(fontName);
-        // Write to PDF
-        return await this.write(font);
-    }
-    /**
-     * Embeds a font from file data with automatic parsing and configuration.
-     * This is the recommended high-level API for embedding fonts.
-     *
-     * @param fontData - The font file bytes (TTF, OTF, or WOFF format)
-     * @param options - Optional configuration
-     * @param options.fontName - Custom font name (defaults to PostScript name from font)
-     * @param options.unicode - Use Unicode/Type0 encoding for non-ASCII characters
-     * @param options.unicodeMappings - Custom CID to Unicode mappings for Type0 fonts
-     * @returns A PdfFont object representing the embedded font
-     *
-     * @example
-     * ```typescript
-     * // Simple embedding with auto-generated name
-     * const font = await document.fonts.embedFromFile(fontData)
-     * field.font = font
-     *
-     * // With custom name and Unicode support
-     * const font = await document.fonts.embedFromFile(fontData, {
-     *     fontName: 'MyCustomFont',
-     *     unicode: true
-     * })
-     * ```
-     */
-    async embedFromFile(fontData, options) {
-        // Parse the font to extract metadata
-        const parser = parseFont(fontData);
-        const info = parser.getFontInfo();
-        // Auto-generate font name from metadata if not provided
-        const fontName = options?.fontName ?? info.postScriptName ?? info.fullName;
-        // Get the appropriate descriptor based on unicode option
-        const descriptor = parser.getFontDescriptor(fontName);
-        // Embed using the appropriate method and return PdfFont
-        if (options?.unicode) {
-            // For Unicode fonts, we need a UnicodeFontDescriptor
-            // Create one by extending the base descriptor
-            const unicodeDescriptor = {
-                ...descriptor,
-                defaultWidth: 1000,
-                cidToGidMap: 'Identity',
-            };
-            return await this.embedTrueTypeFontUnicode(fontData, fontName, unicodeDescriptor, options.unicodeMappings);
-        }
-        else {
-            // Use standard TrueType embedding
-            return await this.embedTrueTypeFont(fontData, fontName, descriptor);
-        }
-    }
-    /**
-     * Gets the font reference by font name or resource name.
-     */
-    async getFont(fontName) {
-        return await this.searchFontInPdf(fontName);
-    }
-    /**
-     * Writes a font to the PDF document.
-     * Assigns resource name, creates container object, commits all objects,
-     * and registers it in page resources.
-     *
-     * @param font - The PdfFont instance to write
-     * @param cacheKey - Unused, kept for API compatibility
-     * @returns The font with its resourceName and container set
-     * @internal
-     */
-    async write(font) {
-        // Assign resource name
-        this.fontResourceCounter++;
-        const resourceName = `F${this.fontResourceCounter}`;
-        font.resourceName = resourceName;
-        // Create container that wraps the font dictionary
-        const fontObject = new PdfIndirectObject({
-            content: font,
-        });
-        font.container = fontObject;
-        // Get all objects to commit (auxiliary objects + container)
-        const objectsToCommit = font.getObjectsToCommit();
-        if (objectsToCommit.length > 0) {
-            await this.document.commit(...objectsToCommit);
-        }
-        // Register in page resources
-        await this.addFontToPageResources(resourceName, fontObject);
-        return font;
-    }
-    /**
-     * Gets all embedded fonts.
-     * Searches the PDF structure to find all fonts.
-     */
-    async getAllFonts() {
-        return await this.collectAllFontsFromPdf();
-    }
-    /**
-     * Embeds a TrueType font with Unicode/Type0 support.
-     * Use this for fonts that need to display non-ASCII characters.
-     *
-     * @param fontData - The font file bytes
-     * @param fontName - The name to use for this font in the PDF
-     * @param descriptor - Unicode font descriptor with CID metrics
-     * @param unicodeMappings - Map of CID to Unicode code point for ToUnicode CMap
-     * @returns A PdfFont object representing the embedded font
-     */
-    async embedTrueTypeFontUnicode(fontData, fontName, descriptor, unicodeMappings) {
-        // Create font using factory
-        const font = PdfFont.fromType0Data(fontData, fontName, descriptor, unicodeMappings);
-        // Write to PDF
-        return await this.write(font);
-    }
-    /**
-     * Loads existing fonts from the PDF document.
-     * Traverses the page tree and extracts font information from page resources.
-     *
-     * @returns Map of font names to their PdfFont objects
-     */
-    async loadExistingFonts() {
-        return await this.collectAllFontsFromPdf();
-    }
-    /**
-     * Traverses the page tree to find and load existing fonts.
-     */
-    async traversePageTreeForFonts(nodeRef, fonts) {
-        const nodeObject = await this.document.readObject({
-            objectNumber: nodeRef.objectNumber,
-            generationNumber: nodeRef.generationNumber,
-        });
-        if (!nodeObject)
-            return;
-        const nodeDict = nodeObject.content.as(PdfDictionary);
-        const type = nodeDict.get('Type')?.as(PdfName);
-        if (type?.value === 'Page') {
-            await this.extractFontsFromPage(nodeObject, nodeDict, fonts);
-        }
-        else if (type?.value === 'Pages') {
-            const kids = nodeDict.get('Kids')?.as(PdfArray);
-            if (kids) {
-                for (const kidRef of kids.items) {
-                    if (kidRef instanceof PdfObjectReference) {
-                        await this.traversePageTreeForFonts(kidRef, fonts);
-                    }
-                }
-            }
-        }
-    }
-    /**
-     * Extracts font information from a page's resources.
-     */
-    async extractFontsFromPage(_pageObject, pageDict, fonts) {
-        // Get Resources - could be direct dict or reference
-        let resources = pageDict.get('Resources')?.as(PdfDictionary);
-        if (!resources) {
-            const resourcesRef = pageDict
-                .get('Resources')
-                ?.as(PdfObjectReference);
-            if (resourcesRef) {
-                const resourcesObj = await this.document.readObject({
-                    objectNumber: resourcesRef.objectNumber,
-                    generationNumber: resourcesRef.generationNumber,
-                });
-                resources = resourcesObj?.content.as(PdfDictionary);
-            }
-        }
-        if (!resources)
-            return;
-        // Get Font dictionary - could be direct dict or reference
-        let fontDict = resources.get('Font')?.as(PdfDictionary);
-        if (!fontDict) {
-            const fontRef = resources.get('Font')?.as(PdfObjectReference);
-            if (fontRef) {
-                const fontObj = await this.document.readObject({
-                    objectNumber: fontRef.objectNumber,
-                    generationNumber: fontRef.generationNumber,
-                });
-                fontDict = fontObj?.content.as(PdfDictionary);
-            }
-        }
-        if (!fontDict)
-            return;
-        // Iterate through fonts in the Font dictionary
-        for (const [resourceName, fontValue] of fontDict.entries()) {
-            // Skip if already in this collection
-            if (fonts.has(resourceName))
-                continue;
-            let fontObjDict;
-            let fontIndirectObj;
-            const fontRef = fontValue.as(PdfObjectReference);
-            if (fontRef) {
-                const obj = await this.document.readObject({
-                    objectNumber: fontRef.objectNumber,
-                    generationNumber: fontRef.generationNumber,
-                });
-                fontObjDict = obj?.content.as(PdfDictionary);
-                fontIndirectObj = obj;
-            }
-            else {
-                fontObjDict = fontValue.as(PdfDictionary);
-            }
-            if (!fontObjDict || !fontIndirectObj)
-                continue;
-            const baseFont = fontObjDict.get('BaseFont')?.as(PdfName)?.value;
-            const encoding = fontObjDict.get('Encoding')?.as(PdfName)?.value;
-            if (baseFont) {
-                const pdfFont = new PdfFont({
-                    fontName: baseFont,
-                    resourceName: resourceName,
-                    encoding: encoding,
-                    manager: this,
-                    container: fontIndirectObj,
-                });
-                fonts.set(resourceName, pdfFont);
-                // Also register by baseFont name for lookup convenience
-                if (!fonts.has(baseFont)) {
-                    fonts.set(baseFont, pdfFont);
-                }
-            }
-        }
-    }
-    /**
-     * Searches the PDF structure for a font by name.
-     * @internal
-     */
-    async searchFontInPdf(fontName) {
-        const fonts = await this.collectAllFontsFromPdf();
-        return fonts?.get(fontName);
-    }
-    /**
-     * Collects all fonts from the PDF structure.
-     * @internal
-     */
-    async collectAllFontsFromPdf() {
-        const fonts = new Map();
-        const catalog = this.document.root;
-        if (!catalog)
-            return fonts;
-        const pagesRef = catalog.content.get('Pages');
-        if (!pagesRef)
-            return fonts;
-        const pagesObjRef = pagesRef.as(PdfObjectReference);
-        if (!pagesObjRef)
-            return fonts;
-        await this.traversePageTreeForFonts(pagesObjRef, fonts);
-        return fonts;
-    }
-    /**
-     * Adds a font to the AcroForm default resources (DR) dictionary.
-     * This ensures fonts are available to form fields.
-     */
-    async addFontToAcroFormResources(resourceName, fontObject) {
-        const catalog = this.document.root;
-        if (!catalog)
-            return;
-        // Get AcroForm dictionary
-        const acroFormRef = catalog.content.get('AcroForm');
-        if (!acroFormRef)
-            return;
-        let acroFormDict;
-        let acroFormContainer;
-        if (acroFormRef instanceof PdfObjectReference) {
-            const acroFormObject = await this.document.readObject({
-                objectNumber: acroFormRef.objectNumber,
-                generationNumber: acroFormRef.generationNumber,
-            });
-            if (acroFormObject) {
-                acroFormDict = acroFormObject.content.as(PdfDictionary);
-                acroFormContainer = acroFormObject;
-            }
-        }
-        else {
-            acroFormDict = acroFormRef.as(PdfDictionary);
-        }
-        if (!acroFormDict)
-            return;
-        // Get or create DR (Default Resources) dictionary
-        let dr = acroFormDict.get('DR')?.as(PdfDictionary);
-        if (!dr) {
-            dr = new PdfDictionary();
-            acroFormDict.set('DR', dr);
-        }
-        // Get or create Font dictionary within DR
-        let fontDict = dr.get('Font')?.as(PdfDictionary);
-        if (!fontDict) {
-            fontDict = new PdfDictionary();
-            dr.set('Font', fontDict);
-        }
-        // Add the font reference
-        fontDict.set(resourceName, fontObject.reference);
-        // Commit the modified AcroForm object if it's an indirect object
-        if (acroFormContainer) {
-            await this.document.commit(acroFormContainer);
-        }
-    }
-    /**
-     * Adds a font to the global /Pages node Resources dictionary.
-     * All child pages will inherit these fonts automatically.
-     * This is more efficient than adding to each individual page.
-     */
-    async addFontToPageResources(resourceName, fontObject) {
-        const catalog = this.document.root;
-        const pagesRef = catalog.content.get('Pages');
-        if (!pagesRef)
-            return;
-        const pagesObjRef = pagesRef.as(PdfObjectReference);
-        if (!pagesObjRef)
-            return;
-        // Read the root /Pages object
-        const pagesObject = await this.document.readObject({
-            objectNumber: pagesObjRef.objectNumber,
-            generationNumber: pagesObjRef.generationNumber,
-        });
-        if (!pagesObject)
-            return;
-        const pagesDict = pagesObject.content.as(PdfDictionary);
-        if (!pagesDict)
-            return;
-        // Get or create Resources dictionary on the /Pages node
-        let resources = pagesDict.get('Resources')?.as(PdfDictionary);
-        if (!resources) {
-            resources = new PdfDictionary();
-            pagesDict.set('Resources', resources);
-        }
-        // Get or create Font dictionary within Resources
-        let fontDict = resources.get('Font')?.as(PdfDictionary);
-        if (!fontDict) {
-            fontDict = new PdfDictionary();
-            resources.set('Font', fontDict);
-        }
-        // Add the font reference to the global dictionary
-        fontDict.set(resourceName, fontObject.reference);
-        // Commit the modified /Pages object
-        await this.document.commit(pagesObject);
-        // Also add to AcroForm DR if AcroForm exists
-        await this.addFontToAcroFormResources(resourceName, fontObject);
-    }
-}

package/dist/utils/predictors.d.ts

@@ -1,113 +0,0 @@
-import { PdfDictionary } from '../core/objects/pdf-dictionary.js';
-import { ByteArray, DecodeParms } from '../types.js';
-/**
- * Handles PNG and TIFF predictor encoding and decoding for PDF streams.
- * Predictors are used to improve compression efficiency by transforming
- * image data before or after compression.
- */
-export declare class Predictor {
-    /**
-     * Decodes data that was encoded with a predictor.
-     *
-     * @param data - The encoded data to decode.
-     * @param params - Optional decode parameters including Predictor, Columns, Colors, and BitsPerComponent.
-     * @returns The decoded byte array.
-     *
-     * @example
-     * ```typescript
-     * const decoded = Predictor.decode(encodedData, { Predictor: 12, Columns: 100 })
-     * ```
-     */
-    static decode(data: ByteArray, params?: DecodeParms): ByteArray;
-    /**
-     * Encodes data using a predictor algorithm.
-     *
-     * @param data - The data to encode.
-     * @param params - Optional encode parameters including Predictor, Columns, Colors, and BitsPerComponent.
-     * @param PdfStreamFilterType - The PNG filter type to use for encoding.
-     * @returns The encoded byte array.
-     *
-     * @example
-     * ```typescript
-     * const encoded = Predictor.encode(rawData, { Predictor: 12, Columns: 100 }, 1)
-     * ```
-     */
-    static encode(data: ByteArray, params?: DecodeParms, PdfStreamFilterType?: number): ByteArray;
-    /**
-     * Decodes TIFF predictor encoded data.
-     *
-     * @param data - The TIFF encoded data.
-     * @param columns - The number of columns in the image.
-     * @param bpp - Bytes per pixel.
-     * @returns The decoded byte array.
-     */
-    static tiffDecode(data: ByteArray, columns: number, bpp: number): ByteArray;
-    /**
-     * Encodes data using TIFF predictor.
-     *
-     * @param data - The data to encode.
-     * @param columns - The number of columns in the image.
-     * @param bpp - Bytes per pixel.
-     * @returns The TIFF encoded byte array.
-     */
-    static tiffEncode(data: ByteArray, columns: number, bpp: number): ByteArray;
-    /**
-     * Decodes PNG predictor encoded data.
-     *
-     * @param data - The PNG encoded data.
-     * @param columns - The number of columns in the image.
-     * @param bpp - Bytes per pixel.
-     * @returns The decoded byte array.
-     * @throws Error if an unsupported PNG filter type is encountered.
-     */
-    static pngDecode(data: ByteArray, columns: number, bpp: number): ByteArray;
-    /**
-     * Encodes data using PNG predictor.
-     *
-     * @param data - The data to encode.
-     * @param columns - The number of columns in the image.
-     * @param bpp - Bytes per pixel.
-     * @param PdfStreamFilterType - The PNG filter type (0-4) to use.
-     * @returns The PNG encoded byte array.
-     * @throws Error if an unsupported PNG filter type is specified.
-     */
-    static pngEncode(data: ByteArray, columns: number, bpp: number, PdfStreamFilterType: number): ByteArray;
-    /**
-     * Implements the Paeth predictor algorithm used in PNG filtering.
-     *
-     * @param a - The left pixel value.
-     * @param b - The above pixel value.
-     * @param c - The upper-left pixel value.
-     * @returns The predicted pixel value.
-     */
-    private static paethPredictor;
-    /**
-     * Extracts decode parameters from a PDF dictionary.
-     *
-     * @param decodeParms - Optional PDF dictionary containing decode parameters.
-     * @returns The decode parameters object or null if not applicable.
-     *
-     * @example
-     * ```typescript
-     * const params = Predictor.getDecodeParms(dictionary)
-     * if (params) {
-     *   console.log(params.Predictor)
-     * }
-     * ```
-     */
-    static getDecodeParms(decodeParms?: PdfDictionary): DecodeParms | null;
-    /**
-     * Checks if the decode parameters can be handled by this predictor.
-     *
-     * @param decodeParms - Optional PDF dictionary containing decode parameters.
-     * @returns True if the parameters can be handled, false otherwise.
-     *
-     * @example
-     * ```typescript
-     * if (Predictor.canHandleDecodeParms(dictionary)) {
-     *   // Process with predictor
-     * }
-     * ```
-     */
-    static canHandleDecodeParms(decodeParms?: PdfDictionary): boolean;
-}