pdf-lite 1.2.1 → 1.3.1

package/dist/pdf/pdf-revision.js

@@ -1,6 +1,7 @@
 import { PdfIndirectObject } from '../core/objects/pdf-indirect-object.js';
 import { PdfObject } from '../core/objects/pdf-object.js';
 import { PdfWhitespaceToken } from '../core/tokens/whitespace-token.js';
+import { PdfComment } from '../index.js';
 import { PdfXrefLookup } from './pdf-xref-lookup.js';
 /**
  * Represents a single revision of a PDF document.
@@ -8,12 +9,13 @@ import { PdfXrefLookup } from './pdf-xref-lookup.js';
  * where each revision contains its own set of objects and cross-reference table.
  */
 export class PdfRevision extends PdfObject {
-    /** Objects contained in this revision */
-    objects = [];
+    /** Objects contained in this revision (private backing field) */
+    _objects = [];
+    /** Whether this revision is locked (private backing field) */
+    _locked = false;
     /** Cross-reference lookup table for this revision */
     xref;
-    /** Whether this revision is locked (cannot be modified) */
-    locked = false;
+    cachedBytes;
     /**
      * Creates a new PDF revision.
      *
@@ -25,13 +27,67 @@ export class PdfRevision extends PdfObject {
     constructor(options) {
         super();
         this.modified = false;
-        this.objects = options?.objects ?? [];
-        this.xref = PdfXrefLookup.fromObjects(this.objects);
+        this._objects = options?.objects ?? [];
+        this.xref = PdfXrefLookup.fromObjects(this._objects);
         if (options?.prev)
             this.setPrev(options.prev);
         if (!this.contains(this.xref.object))
             this.addObject(...this.xref.toTrailerSection());
-        this.locked = options?.locked ?? false;
+        this._locked = options?.locked ?? false;
+    }
+    get header() {
+        const firstObj = this._objects[0];
+        if (firstObj instanceof PdfComment && firstObj.isVersionComment()) {
+            return firstObj;
+        }
+        return undefined;
+    }
+    set header(comment) {
+        if (this._locked) {
+            throw new Error('Cannot modify header in locked PDF revision');
+        }
+        const currentHeader = this.header;
+        if (currentHeader) {
+            this._objects[0] = comment;
+        }
+        else
+            this._objects.unshift(comment);
+    }
+    /**
+     * Gets whether this revision is locked (cannot be modified).
+     */
+    get locked() {
+        return this._locked;
+    }
+    /**
+     * Sets whether this revision is locked.
+     * When locking, creates a cached clone of all objects to freeze their state.
+     * When unlocking, clears the cache.
+     */
+    set locked(value) {
+        this._locked = value;
+        this.cachedBytes = value ? this.toBytes() : undefined;
+        for (const obj of this._objects) {
+            obj.setImmutable(value);
+        }
+    }
+    /**
+     * Gets the objects in this revision.
+     * Returns fresh clones of cached objects if the revision is locked, otherwise returns live objects.
+     * Each access to a locked revision's objects returns new clones to prevent mutations.
+     */
+    get objects() {
+        return this._objects;
+    }
+    /**
+     * Sets the objects array.
+     * @throws Error if the revision is locked
+     */
+    set objects(value) {
+        if (this._locked) {
+            throw new Error('Cannot modify objects array in locked revision');
+        }
+        this._objects = value;
     }
     /**
      * Links this revision to a previous revision's cross-reference table.
@@ -49,7 +105,7 @@ export class PdfRevision extends PdfObject {
      * @returns True if the exact object instance exists in this revision
      */
     contains(object) {
-        return this.objects.includes(object);
+        return this._objects.includes(object);
     }
     /**
      * Checks if an equivalent object exists in this revision (by value equality).
@@ -58,7 +114,7 @@ export class PdfRevision extends PdfObject {
      * @returns True if an equal object exists in this revision
      */
     exists(object) {
-        for (const obj of this.objects) {
+        for (const obj of this._objects) {
             if (obj.equals(object)) {
                 return true;
             }
@@ -69,10 +125,14 @@ export class PdfRevision extends PdfObject {
      * Adds objects to the beginning of the revision's object list.
      *
      * @param objects - Objects to add at the beginning
+     * @throws Error if the revision is locked
      */
     unshift(...objects) {
+        if (this._locked) {
+            throw new Error('Cannot add object to locked PDF revision');
+        }
         for (const obj of objects.reverse()) {
-            this.objects.unshift(obj);
+            this._objects.unshift(obj);
             if (obj instanceof PdfIndirectObject)
                 this.xref.addObject(obj);
         }
@@ -81,8 +141,12 @@ export class PdfRevision extends PdfObject {
      * Adds objects to the revision.
      *
      * @param objects - Objects to add to the revision
+     * @throws Error if the revision is locked
      */
     addObject(...objects) {
+        if (this._locked) {
+            throw new Error('Cannot add object to locked PDF revision');
+        }
         for (const obj of objects) {
             this.addObjectAt(obj);
         }
@@ -95,25 +159,25 @@ export class PdfRevision extends PdfObject {
      * @throws Error if the revision is locked or index is out of bounds
      */
     addObjectAt(object, index) {
-        if (this.locked) {
+        if (this._locked) {
             throw new Error('Cannot add object to locked PDF revision');
         }
         if (index === undefined) {
             index =
                 object instanceof PdfIndirectObject
                     ? this.xref.object
-                    : this.objects.length;
+                    : this._objects.length;
         }
         if (typeof index !== 'number') {
-            index = this.objects.indexOf(index);
+            index = this._objects.indexOf(index);
             if (index === -1) {
-                index = this.objects.length;
+                index = this._objects.length;
             }
         }
-        if (index < 0 || index > this.objects.length) {
+        if (index < 0 || index > this._objects.length) {
             throw new Error('Index out of bounds');
         }
-        this.objects.splice(index, 0, object);
+        this._objects.splice(index, 0, object);
         this.sortObjects();
         if (object instanceof PdfIndirectObject) {
             this.xref.addObject(object);
@@ -127,16 +191,16 @@ export class PdfRevision extends PdfObject {
      * @throws Error if the revision is locked
      */
     deleteObject(...objects) {
-        if (this.locked) {
+        if (this._locked) {
             throw new Error('Cannot delete object from locked PDF revision');
         }
         for (const object of objects) {
-            const index = this.objects.indexOf(object);
+            const index = this._objects.indexOf(object);
             if (index === -1) {
                 return;
             }
             this.modified = true;
-            this.objects.splice(index, 1);
+            this._objects.splice(index, 1);
             if (object instanceof PdfIndirectObject) {
                 this.xref.removeObject(object);
             }
@@ -145,13 +209,13 @@ export class PdfRevision extends PdfObject {
     isModified() {
         return (super.isModified() ||
             this.xref.trailerDict.isModified() ||
-            this.objects.some((obj) => obj.isModified()));
+            this._objects.some((obj) => obj.isModified()));
     }
     /**
      * Updates the revision by sorting objects and updating the xref table.
      */
     update() {
-        if (this.locked) {
+        if (this._locked) {
             return;
         }
         this.sortObjects();
@@ -163,7 +227,7 @@ export class PdfRevision extends PdfObject {
      * Indirect objects are placed before other objects.
      */
     sortObjects() {
-        this.objects.sort((a, b) => {
+        this._objects.sort((a, b) => {
             if (a instanceof PdfIndirectObject &&
                 b instanceof PdfIndirectObject) {
                 return a.order() - b.order();
@@ -191,9 +255,19 @@ export class PdfRevision extends PdfObject {
         return new PdfRevision({ objects: clonedObjects });
     }
     tokenize() {
-        return this.objects.flatMap((obj) => [
-            ...obj.toTokens(),
-            PdfWhitespaceToken.NEWLINE,
-        ]);
+        const output = this.objects.flatMap((obj) => {
+            const objTokens = obj.toTokens();
+            if (!(objTokens[objTokens.length - 1] instanceof PdfWhitespaceToken)) {
+                objTokens.push(new PdfWhitespaceToken('\n'));
+            }
+            return objTokens;
+        });
+        return output;
+    }
+    toBytes() {
+        if (this.cachedBytes) {
+            return this.cachedBytes;
+        }
+        return super.toBytes();
     }
 }

package/dist/pdf/pdf-xref-lookup.js

@@ -375,10 +375,11 @@ export class PdfXrefLookup {
      * @returns The xref entry or undefined if not found
      */
     getObject(objectNumber) {
-        if (!this.entries.has(objectNumber) && this.prev) {
+        const entry = this.entries.get(objectNumber);
+        if (this.prev && !entry) {
             return this.prev.getObject(objectNumber);
         }
-        return this.entries.get(objectNumber);
+        return entry;
     }
     /**
      * Generates the trailer section objects for this xref.

package/dist/utils/decodeWithFontEncoding.d.ts

@@ -0,0 +1,20 @@
+import { ByteArray } from '../types.js';
+import { PdfArray } from '../core/objects/pdf-array.js';
+/**
+ * Builds a character encoding map from a PDF Encoding Differences array.
+ * The Differences array format is: [code name1 name2 ... code name1 name2 ...]
+ * where code is a number and names are glyph names.
+ *
+ * @param differences - PdfArray containing the Differences array
+ * @returns Map from byte code to Unicode character
+ */
+export declare function buildEncodingMap(differences: PdfArray): Map<number, string> | null;
+/**
+ * Decodes a byte array using a custom font encoding map.
+ * Falls back to PDFDocEncoding for unmapped bytes.
+ *
+ * @param bytes - The byte array to decode
+ * @param encodingMap - Map from byte code to Unicode character
+ * @returns The decoded string
+ */
+export declare function decodeWithFontEncoding(bytes: ByteArray, encodingMap: Map<number, string> | null): string;

package/dist/utils/decodeWithFontEncoding.js

@@ -0,0 +1,67 @@
+import { PdfName } from '../core/objects/pdf-name.js';
+import { PdfNumber } from '../core/objects/pdf-number.js';
+import { GLYPH_NAME_TO_UNICODE } from './glyphNameToUnicode.js';
+import { decodeFromPDFDocEncoding } from './decodeFromPDFDocEncoding.js';
+/**
+ * Builds a character encoding map from a PDF Encoding Differences array.
+ * The Differences array format is: [code name1 name2 ... code name1 name2 ...]
+ * where code is a number and names are glyph names.
+ *
+ * @param differences - PdfArray containing the Differences array
+ * @returns Map from byte code to Unicode character
+ */
+export function buildEncodingMap(differences) {
+    const encodingMap = new Map();
+    let currentCode = 0;
+    for (const item of differences.items) {
+        if (item instanceof PdfNumber) {
+            // This is a starting code
+            currentCode = item.value;
+        }
+        else if (item instanceof PdfName) {
+            // This is a glyph name
+            const glyphName = item.value;
+            const unicode = GLYPH_NAME_TO_UNICODE[glyphName];
+            if (unicode) {
+                encodingMap.set(currentCode, unicode);
+            }
+            currentCode++;
+        }
+    }
+    return encodingMap.size > 0 ? encodingMap : null;
+}
+/**
+ * Decodes a byte array using a custom font encoding map.
+ * Falls back to PDFDocEncoding for unmapped bytes.
+ *
+ * @param bytes - The byte array to decode
+ * @param encodingMap - Map from byte code to Unicode character
+ * @returns The decoded string
+ */
+export function decodeWithFontEncoding(bytes, encodingMap) {
+    if (!encodingMap) {
+        return decodeFromPDFDocEncoding(bytes);
+    }
+    let result = '';
+    for (let i = 0; i < bytes.length; i++) {
+        const byte = bytes[i];
+        const mapped = encodingMap.get(byte);
+        if (mapped !== undefined) {
+            result += mapped;
+        }
+        else {
+            // Fall back to PDFDocEncoding for unmapped bytes
+            if (byte < 128) {
+                result += String.fromCharCode(byte);
+            }
+            else if (byte >= 160) {
+                result += String.fromCharCode(byte);
+            }
+            else {
+                // Byte 128-159 range - use PDFDocEncoding
+                result += decodeFromPDFDocEncoding(new Uint8Array([byte]));
+            }
+        }
+    }
+    return result;
+}

package/dist/utils/escapeString.d.ts

@@ -1,7 +1,7 @@
 import { ByteArray } from '../types.js';
 /**
  * Escapes special characters in a PDF string according to PDF specification.
- * Escapes parentheses, backslashes, line feeds, and carriage returns.
+ * Escapes parentheses, backslashes, and control characters (\n, \r, \t, \b, \f).
  *
  * @param bytes - The byte array or string to escape.
  * @returns A new byte array with escaped characters.

package/dist/utils/escapeString.js

@@ -1,7 +1,7 @@
 import { stringToBytes } from './stringToBytes.js';
 /**
  * Escapes special characters in a PDF string according to PDF specification.
- * Escapes parentheses, backslashes, line feeds, and carriage returns.
+ * Escapes parentheses, backslashes, and control characters (\n, \r, \t, \b, \f).
  *
  * @param bytes - The byte array or string to escape.
  * @returns A new byte array with escaped characters.
@@ -30,10 +30,19 @@ export function escapeString(bytes) {
                 break; // \
             case 0x0a:
                 result.push(BACKSLASH, 0x6e);
-                break; // LF
+                break; // \n (LF)
             case 0x0d:
                 result.push(BACKSLASH, 0x72);
-                break; // CR
+                break; // \r (CR)
+            case 0x09:
+                result.push(BACKSLASH, 0x74);
+                break; // \t (Tab)
+            case 0x08:
+                result.push(BACKSLASH, 0x62);
+                break; // \b (Backspace)
+            case 0x0c:
+                result.push(BACKSLASH, 0x66);
+                break; // \f (Form feed)
             default:
                 result.push(b);
                 break;

package/dist/utils/glyphNameToUnicode.d.ts

@@ -0,0 +1,10 @@
+/**
+ * Maps PostScript glyph names to Unicode characters.
+ * Based on Adobe Glyph List Specification.
+ *
+ * Source: https://github.com/adobe-type-tools/agl-aglfn
+ *
+ * Copyright 2002-2019 Adobe (http://www.adobe.com/).
+ * Licensed under BSD-3-Clause.
+ */
+export declare const GLYPH_NAME_TO_UNICODE: Record<string, string>;