pdf-lite 1.6.4 → 1.7.1

package/dist/core/objects/pdf-xref-table.d.ts

@@ -1,6 +1,5 @@
 import { Ref } from '../ref.js';
-import { PdfXRefTableEntryToken } from '../tokens/xref-table-entry-token.js';
-import { PdfXRefTableSectionStartToken } from '../tokens/xref-table-section-start-token.js';
+import { PdfToken } from '../tokens/token.js';
 import { PdfIndirectObject } from './pdf-indirect-object.js';
 import { PdfNumber } from './pdf-number.js';
 import { PdfObject } from './pdf-object.js';
@@ -15,8 +14,15 @@ export declare class PdfXRefTableEntry extends PdfObject {
         generationNumber: number | PdfNumber;
         inUse: boolean;
     });
-    protected tokenize(): PdfXRefTableEntryToken[];
+    protected tokenize(): PdfToken[];
     cloneImpl(): this;
+    toJSON(): {
+        type: string;
+        objectNumber: number;
+        generationNumber: number;
+        byteOffset: number;
+        inUse: boolean;
+    };
     isModified(): boolean;
 }
 export declare class PdfXRefTableSectionHeader extends PdfObject {
@@ -26,8 +32,13 @@ export declare class PdfXRefTableSectionHeader extends PdfObject {
         startObjectNumber: number | PdfNumber;
         entryCount: number | PdfNumber;
     });
-    protected tokenize(): PdfXRefTableSectionStartToken[];
+    protected tokenize(): PdfToken[];
     cloneImpl(): this;
+    toJSON(): {
+        type: string;
+        startObjectNumber: number;
+        entryCount: number;
+    };
 }
 export declare class PdfXRefTable extends PdfObject {
     sections: PdfXRefTableSectionHeader[];
@@ -42,7 +53,22 @@ export declare class PdfXRefTable extends PdfObject {
     addEntryForObject(obj: PdfIndirectObject): void;
     getEntry(objectNumber: number): PdfXRefTableEntry | undefined;
     get lastSection(): PdfXRefTableSectionHeader | null;
-    protected tokenize(): import("../index.js").PdfToken[];
+    protected tokenize(): PdfToken[];
     private sortEntriesIntoSections;
     cloneImpl(): this;
+    toJSON(): {
+        type: string;
+        sections: {
+            type: string;
+            startObjectNumber: number;
+            entryCount: number;
+        }[];
+        entries: {
+            type: string;
+            objectNumber: number;
+            generationNumber: number;
+            byteOffset: number;
+            inUse: boolean;
+        }[];
+    };
 }

package/dist/core/objects/pdf-xref-table.js

@@ -44,6 +44,15 @@ export class PdfXRefTableEntry extends PdfObject {
             inUse: this.inUse,
         });
     }
+    toJSON() {
+        return {
+            type: 'xref-entry',
+            objectNumber: this.objectNumber.value,
+            generationNumber: this.generationNumber.value,
+            byteOffset: this.byteOffset.value,
+            inUse: this.inUse,
+        };
+    }
     isModified() {
         return (super.isModified() ||
             this.byteOffset.isModified() ||
@@ -70,6 +79,13 @@ export class PdfXRefTableSectionHeader extends PdfObject {
             entryCount: this.entryCount.clone(),
         });
     }
+    toJSON() {
+        return {
+            type: 'xref-section-header',
+            startObjectNumber: this.startObjectNumber.value,
+            entryCount: this.entryCount.value,
+        };
+    }
 }
 export class PdfXRefTable extends PdfObject {
     sections;
@@ -180,4 +196,11 @@ export class PdfXRefTable extends PdfObject {
             offset: new Ref(this.offset.resolve()),
         });
     }
+    toJSON() {
+        return {
+            type: 'xref-table',
+            sections: this.sections.map((s) => s.toJSON()),
+            entries: this.entries.map((e) => e.toJSON()),
+        };
+    }
 }

package/dist/fonts/font-family.d.ts

@@ -0,0 +1,12 @@
+import type { PdfFont } from './pdf-font.js';
+/**
+ * A group of font variants for a single typeface family.
+ * Set on a form field via `field.fontFamily` to enable true bold/italic
+ * rendering in markdown appearance streams rather than stroke simulation.
+ */
+export interface FontFamily {
+    regular: PdfFont;
+    bold?: PdfFont;
+    italic?: PdfFont;
+    boldItalic?: PdfFont;
+}

package/dist/fonts/font-family.js

@@ -0,0 +1 @@
+export {};

package/dist/fonts/index.d.ts

@@ -1,3 +1,4 @@
 export * from './types.js';
 export * from './pdf-font.js';
+export * from './font-family.js';
 export * from './parsers/index.js';

package/dist/fonts/index.js

@@ -1,3 +1,4 @@
 export * from './types.js';
 export * from './pdf-font.js';
+export * from './font-family.js';
 export * from './parsers/index.js';

package/dist/fonts/parsers/otf-parser.d.ts

@@ -41,10 +41,10 @@ export declare class OtfParser implements FontParser {
     private parseOS2;
     private parsePost;
     private parseName;
-    private parseCmap;
+    parseCmap(): Map<number, number>;
     private parseCmapFormat4;
     private parseCmapFormat12;
-    private parseHmtx;
+    parseHmtx(): Map<number, number>;
     private parseMaxp;
     private estimateStemV;
 }

package/dist/fonts/parsers/ttf-parser.d.ts

@@ -33,10 +33,10 @@ export declare class TtfParser implements FontParser {
     private parseOS2;
     private parsePost;
     private parseName;
-    private parseCmap;
+    parseCmap(): Map<number, number>;
     private parseCmapFormat4;
     private parseCmapFormat12;
-    private parseHmtx;
+    parseHmtx(): Map<number, number>;
     private parseMaxp;
     private estimateStemV;
 }

package/dist/fonts/parsers/woff-parser.d.ts

@@ -24,6 +24,8 @@ export declare class WoffParser implements FontParser {
      * Gets character widths for a range of characters.
      */
     getCharWidths(firstChar: number, lastChar: number): number[];
+    parseCmap(): Map<number, number>;
+    parseHmtx(): Map<number, number>;
     private decompressWoff;
 }
 /**

package/dist/fonts/parsers/woff-parser.js

@@ -35,6 +35,12 @@ export class WoffParser {
     getCharWidths(firstChar, lastChar) {
         return this.ttfParser.getCharWidths(firstChar, lastChar);
     }
+    parseCmap() {
+        return this.ttfParser.parseCmap();
+    }
+    parseHmtx() {
+        return this.ttfParser.parseHmtx();
+    }
     decompressWoff(woffData) {
         const data = new DataView(woffData.buffer, woffData.byteOffset, woffData.byteLength);
         // Verify WOFF signature

package/dist/fonts/pdf-font.js

@@ -213,6 +213,27 @@ export class PdfFont extends PdfIndirectObject {
      * @returns The raw character width or null if not found
      */
     getRawCharacterWidth(charCode) {
+        // For Type0 fonts, check CID widths in descriptor
+        if (this.isUnicode && this._descriptor) {
+            const unicodeDesc = this._descriptor;
+            if (unicodeDesc.cidWidths) {
+                // Find width for this CID (which equals Unicode code point for Identity-H)
+                for (const entry of unicodeDesc.cidWidths) {
+                    if ('width' in entry && entry.cid === charCode) {
+                        return entry.width;
+                    }
+                    else if ('widths' in entry) {
+                        const offset = charCode - entry.startCid;
+                        if (offset >= 0 && offset < entry.widths.length) {
+                            return entry.widths[offset];
+                        }
+                    }
+                }
+                // Not found, use default width
+                return unicodeDesc.defaultWidth ?? 1000;
+            }
+        }
+        // For Type1/TrueType fonts, use simple widths array
         if (this.widths === undefined || this.firstChar === undefined) {
             return null;
         }
@@ -285,8 +306,7 @@ export class PdfFont extends PdfIndirectObject {
      * @returns A PdfFont instance ready to be written to the PDF
      */
     static fromBytes(data) {
-        const parser = parseFont(data);
-        return PdfFont.fromParser(parser);
+        return PdfFont.fromFile(data);
     }
     /**
      * Creates a PdfFont from a FontParser instance.
@@ -582,8 +602,37 @@ export class PdfFont extends PdfIndirectObject {
         if (descriptor.cidWidths && descriptor.cidWidths.length > 0) {
             cidFontDict.set('W', PdfFont.buildCIDWidthArray(descriptor.cidWidths));
         }
-        // CIDToGIDMap
-        cidFontDict.set('CIDToGIDMap', new PdfName(descriptor.cidToGidMap ?? 'Identity'));
+        // CIDToGIDMap - Generate binary stream if unicodeMappings provided
+        if (unicodeMappings && unicodeMappings.size > 0) {
+            // Create a binary CIDToGIDMap stream
+            // For Identity-H encoding, CID = Unicode value
+            // We need to map each CID to its GID
+            const maxCid = Math.max(...Array.from(unicodeMappings.keys()));
+            const cidToGidData = new Uint8Array((maxCid + 1) * 2);
+            // Initialize all mappings to 0 (missing glyph)
+            for (let i = 0; i < cidToGidData.length; i++) {
+                cidToGidData[i] = 0;
+            }
+            // Fill in the mappings
+            for (const [unicode, glyphId] of unicodeMappings.entries()) {
+                const offset = unicode * 2;
+                // Big-endian 16-bit glyph ID
+                cidToGidData[offset] = (glyphId >> 8) & 0xff;
+                cidToGidData[offset + 1] = glyphId & 0xff;
+            }
+            const cidToGidStream = new PdfStream({
+                header: new PdfDictionary(),
+                original: cidToGidData,
+            });
+            cidToGidStream.addFilter('FlateDecode');
+            const cidToGidObject = new PdfIndirectObject({
+                content: cidToGidStream,
+            });
+            cidFontDict.set('CIDToGIDMap', cidToGidObject.reference);
+        }
+        else {
+            cidFontDict.set('CIDToGIDMap', new PdfName(descriptor.cidToGidMap ?? 'Identity'));
+        }
         const cidFontObject = new PdfIndirectObject({
             content: cidFontDict,
         });
@@ -611,21 +660,58 @@ export class PdfFont extends PdfIndirectObject {
     static fromFile(fontData, options) {
         // Parse the font to extract metadata
         const parser = parseFont(fontData);
+        // Check if CFF-based OTF (not supported)
+        if (parser instanceof OtfParser && parser.isCFFBased()) {
+            throw new Error('CFF-based OTF fonts are not supported yet');
+        }
         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);
+        // Auto-detect if Unicode font is needed if not explicitly specified
+        let useUnicode = options?.unicode;
+        if (useUnicode === undefined) {
+            // Check if font has glyphs beyond WinAnsiEncoding range (0-255)
+            const cmap = parser.parseCmap();
+            useUnicode = Array.from(cmap.keys()).some((unicode) => unicode > 0xff);
+        }
         // Embed using the appropriate method and return PdfFont
-        if (options?.unicode) {
+        if (useUnicode) {
+            // Auto-extract cmap if not provided
+            const unicodeMappings = options?.unicodeMappings ?? parser.parseCmap();
+            // Extract glyph widths for Unicode characters
+            const hmtx = parser.parseHmtx();
+            const unitsPerEm = info.unitsPerEm;
+            const cidWidths = [];
+            // Build CID widths array from cmap + hmtx
+            for (const [unicode, glyphId] of unicodeMappings.entries()) {
+                const glyphWidth = hmtx.get(glyphId) ?? 0;
+                // Scale to 1000-unit em square
+                const scaledWidth = Math.round((glyphWidth * 1000) / unitsPerEm);
+                cidWidths.push({ cid: unicode, width: scaledWidth });
+            }
+            // Compute average width for default
+            const avgWidth = cidWidths.length > 0
+                ? Math.round(cidWidths.reduce((sum, entry) => {
+                    if ('width' in entry) {
+                        return sum + entry.width;
+                    }
+                    else {
+                        // Average the widths in the range
+                        const rangeSum = entry.widths.reduce((a, b) => a + b, 0);
+                        return sum + rangeSum / entry.widths.length;
+                    }
+                }, 0) / cidWidths.length)
+                : 1000;
             // For Unicode fonts, we need a UnicodeFontDescriptor
-            // Create one by extending the base descriptor
             const unicodeDescriptor = {
                 ...descriptor,
-                defaultWidth: 1000,
+                defaultWidth: avgWidth,
+                cidWidths,
                 cidToGidMap: 'Identity',
             };
-            return PdfFont.fromType0Data(fontData, fontName, unicodeDescriptor, options.unicodeMappings);
+            return PdfFont.fromType0Data(fontData, fontName, unicodeDescriptor, unicodeMappings);
         }
         else {
             // Use standard TrueType embedding

package/dist/fonts/types.d.ts

@@ -8,6 +8,16 @@ export interface FontParser {
     getFontDescriptor(fontName?: string): FontDescriptor;
     getCharWidths(firstChar: number, lastChar: number): number[];
     getFontData(): ByteArray;
+    /**
+     * Parses the font's cmap table to extract Unicode to glyph ID mappings.
+     * @returns A map from Unicode code points to glyph IDs
+     */
+    parseCmap(): Map<number, number>;
+    /**
+     * Parses the font's hmtx table to extract glyph advance widths.
+     * @returns A map from glyph IDs to advance widths (in font units)
+     */
+    parseHmtx(): Map<number, number>;
 }
 /**
  * Parsed TrueType font information.

package/dist/pdf/pdf-document.d.ts

@@ -311,6 +311,13 @@ export declare class PdfDocument extends PdfObject implements IPdfObjectResolver
      * @returns A cloned PdfDocument instance
      */
     cloneImpl(): this;
+    toJSON(): {
+        type: string;
+        revisions: {
+            type: string;
+            objects: object[];
+        }[];
+    };
     /**
      * Creates a PdfDocument from a byte stream.
      *

package/dist/pdf/pdf-document.js

@@ -967,6 +967,12 @@ export class PdfDocument extends PdfObject {
             securityHandler: this.securityHandler,
         });
     }
+    toJSON() {
+        return {
+            type: 'document',
+            revisions: this.revisions.map((rev) => rev.toJSON()),
+        };
+    }
     /**
      * Creates a PdfDocument from a byte stream.
      *

package/dist/pdf/pdf-revision.d.ts

@@ -124,6 +124,10 @@ export declare class PdfRevision extends PdfObject {
      *
      * @returns A cloned PdfRevision instance
      */
+    toJSON(): {
+        type: string;
+        objects: object[];
+    };
     cloneImpl(): this;
     protected tokenize(): PdfToken[];
     isEmpty(): boolean;

package/dist/pdf/pdf-revision.js

@@ -251,6 +251,12 @@ export class PdfRevision extends PdfObject {
      *
      * @returns A cloned PdfRevision instance
      */
+    toJSON() {
+        return {
+            type: 'revision',
+            objects: this._objects.map((obj) => obj.toJSON()),
+        };
+    }
     cloneImpl() {
         const clonedObjects = this.objects.map((obj) => obj.clone());
         return new PdfRevision({ objects: clonedObjects });

package/dist/utils/iterable-readable-stream.d.ts

@@ -20,5 +20,7 @@ export declare class IterableReadableStream<T> extends ReadableStream<T> {
      */
     [Symbol.asyncIterator](): {
         next(): Promise<IteratorResult<T>>;
+        [Symbol.asyncIterator](): /*elided*/ any;
+        [Symbol.asyncDispose](): Promise<void>;
     };
 }

package/dist/utils/iterable-readable-stream.js

@@ -20,11 +20,18 @@ export class IterableReadableStream extends ReadableStream {
      */
     [Symbol.asyncIterator]() {
         const reader = this.getReader();
-        return {
+        const iterator = {
             async next() {
                 const result = await reader.read();
                 return result;
             },
+            [Symbol.asyncIterator]() {
+                return iterator;
+            },
+            async [Symbol.asyncDispose]() {
+                reader.releaseLock();
+            },
         };
+        return iterator;
     }
 }

package/dist/utils/parse-markdown-segments.d.ts

@@ -0,0 +1,12 @@
+export type StyledSegment = {
+    text: string;
+    bold: boolean;
+    italic: boolean;
+};
+/**
+ * Parses a markdown string with **bold**, *italic*, and ***bold+italic***
+ * syntax into an array of styled text segments.
+ *
+ * Unrecognized or unmatched asterisks are emitted as plain text.
+ */
+export declare function parseMarkdownSegments(text: string): StyledSegment[];

package/dist/utils/parse-markdown-segments.js

@@ -0,0 +1,27 @@
+/**
+ * Parses a markdown string with **bold**, *italic*, and ***bold+italic***
+ * syntax into an array of styled text segments.
+ *
+ * Unrecognized or unmatched asterisks are emitted as plain text.
+ */
+export function parseMarkdownSegments(text) {
+    const segments = [];
+    // Match *** before ** before * to handle longest-match first
+    const re = /\*\*\*(.+?)\*\*\*|\*\*(.+?)\*\*|\*(.+?)\*|([^*]+|\*)/gs;
+    let match;
+    while ((match = re.exec(text)) !== null) {
+        if (match[1] !== undefined) {
+            segments.push({ text: match[1], bold: true, italic: true });
+        }
+        else if (match[2] !== undefined) {
+            segments.push({ text: match[2], bold: true, italic: false });
+        }
+        else if (match[3] !== undefined) {
+            segments.push({ text: match[3], bold: false, italic: true });
+        }
+        else if (match[4] !== undefined && match[4].length > 0) {
+            segments.push({ text: match[4], bold: false, italic: false });
+        }
+    }
+    return segments;
+}

package/dist/utils/xml.d.ts

@@ -0,0 +1,9 @@
+export declare class Xml {
+    static escapeValue(value: string): string;
+    static getElementContent(xml: string, tagName: string): string | null;
+    static setElementContent(xml: string, tagName: string, content: string): string;
+    static hasElement(xml: string, tagName: string): boolean;
+    static insertChild(xml: string, parentTagName: string, childXml: string): string;
+    static wrapInElements(content: string, tagNames: string[]): string;
+    static escapeRegex(str: string): string;
+}

package/dist/utils/xml.js

@@ -0,0 +1,59 @@
+export class Xml {
+    static escapeValue(value) {
+        return value
+            .replace(/&/g, '&')
+            .replace(/</g, '&lt;')
+            .replace(/>/g, '&gt;')
+            .replace(/"/g, '&quot;')
+            .replace(/'/g, '&apos;');
+    }
+    static getElementContent(xml, tagName) {
+        const escaped = Xml.escapeRegex(tagName);
+        const regex = new RegExp(`<${escaped}(?:\\s[^>]*)?>([\\s\\S]*?)</${escaped}\\s*>`);
+        const match = xml.match(regex);
+        return match ? match[1] : null;
+    }
+    static setElementContent(xml, tagName, content) {
+        const escaped = Xml.escapeRegex(tagName);
+        // Try expanding a self-closing tag
+        const selfClosing = new RegExp(`<${escaped}\\s*/>`);
+        if (selfClosing.test(xml)) {
+            return xml.replace(selfClosing, `<${tagName}>${content}</${tagName}>`);
+        }
+        // Try replacing content of an existing tag
+        const contentRegex = new RegExp(`(<${escaped}(?:\\s[^>]*)?>)[\\s\\S]*?(</${escaped}\\s*>)`);
+        if (contentRegex.test(xml)) {
+            return xml.replace(contentRegex, `$1${content}$2`);
+        }
+        return xml;
+    }
+    static hasElement(xml, tagName) {
+        const escaped = Xml.escapeRegex(tagName);
+        return (new RegExp(`</${escaped}\\s*>`).test(xml) ||
+            new RegExp(`<${escaped}\\s*/>`).test(xml));
+    }
+    static insertChild(xml, parentTagName, childXml) {
+        const escaped = Xml.escapeRegex(parentTagName);
+        // Insert before closing tag
+        const closingRegex = new RegExp(`(</${escaped}\\s*>)`);
+        if (closingRegex.test(xml)) {
+            return xml.replace(closingRegex, `${childXml}$1`);
+        }
+        // Expand self-closing tag
+        const selfClosing = new RegExp(`<${escaped}\\s*/>`);
+        if (selfClosing.test(xml)) {
+            return xml.replace(selfClosing, `<${parentTagName}>${childXml}</${parentTagName}>`);
+        }
+        return xml;
+    }
+    static wrapInElements(content, tagNames) {
+        let result = content;
+        for (let i = tagNames.length - 1; i >= 0; i--) {
+            result = `<${tagNames[i]}>${result}</${tagNames[i]}>`;
+        }
+        return result;
+    }
+    static escapeRegex(str) {
+        return str.replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
+    }
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "pdf-lite",
-  "version": "1.6.4",
+  "version": "1.7.1",
   "main": "dist/index.js",
   "type": "module",
   "exports": {
@@ -35,7 +35,7 @@
     "@vitest/browser-playwright": "^4.0.14",
     "@vitest/coverage-v8": "^4.0.14",
     "playwright": "^1.56.1",
-    "typescript": "5.9.3",
+    "typescript": "6.0.2",
     "vitest": "^4.0.14"
   },
   "repository": {