pdf-lite 1.5.0 → 1.6.1

package/dist/annotations/pdf-annotation.js

@@ -4,17 +4,25 @@ import { PdfObjectReference } from '../core/objects/pdf-object-reference.js';
 import { PdfArray } from '../core/objects/pdf-array.js';
 import { PdfNumber } from '../core/objects/pdf-number.js';
 import { PdfAnnotationFlags } from './pdf-annotation-flags.js';
+import { PdfPage } from '../pdf/pdf-page.js';
 /**
  * Base class for all PDF annotations.
  */
 export class PdfAnnotation extends PdfIndirectObject {
     _annotationFlags;
+    get flags_() {
+        if (!this._annotationFlags) {
+            const flagValue = this.content.get('F')?.as(PdfNumber)?.value ?? 0;
+            this._annotationFlags = new PdfAnnotationFlags(flagValue);
+            this.content.set('F', this._annotationFlags);
+        }
+        return this._annotationFlags;
+    }
     constructor(options) {
         super(options?.other ??
             new PdfIndirectObject({ content: new PdfDictionary() }));
-        const flagValue = this.content.get('F')?.as(PdfNumber)?.value ?? 0;
-        this._annotationFlags = new PdfAnnotationFlags(flagValue);
-        this.content.set('F', this._annotationFlags);
+        // Eagerly initialize when constructed normally
+        this.flags_;
     }
     get rect() {
         const rectArray = this.content.get('Rect')?.as((PdfArray));
@@ -31,52 +39,52 @@ export class PdfAnnotation extends PdfIndirectObject {
         this.content.set('Rect', rectArray);
     }
     get annotationFlags() {
-        return this._annotationFlags.annotationFlags;
+        return this.flags_.annotationFlags;
     }
     set annotationFlags(flags) {
-        this._annotationFlags.annotationFlags = flags;
+        this.flags_.annotationFlags = flags;
     }
     get invisible() {
-        return this._annotationFlags.invisible;
+        return this.flags_.invisible;
     }
     set invisible(value) {
-        this._annotationFlags.invisible = value;
+        this.flags_.invisible = value;
     }
     get hidden() {
-        return this._annotationFlags.hidden;
+        return this.flags_.hidden;
     }
     set hidden(value) {
-        this._annotationFlags.hidden = value;
+        this.flags_.hidden = value;
     }
     get print() {
-        return this._annotationFlags.print;
+        return this.flags_.print;
     }
     set print(value) {
-        this._annotationFlags.print = value;
+        this.flags_.print = value;
     }
     get noZoom() {
-        return this._annotationFlags.noZoom;
+        return this.flags_.noZoom;
     }
     set noZoom(value) {
-        this._annotationFlags.noZoom = value;
+        this.flags_.noZoom = value;
     }
     get noRotate() {
-        return this._annotationFlags.noRotate;
+        return this.flags_.noRotate;
     }
     set noRotate(value) {
-        this._annotationFlags.noRotate = value;
+        this.flags_.noRotate = value;
     }
     get noView() {
-        return this._annotationFlags.noView;
+        return this.flags_.noView;
     }
     set noView(value) {
-        this._annotationFlags.noView = value;
+        this.flags_.noView = value;
     }
     get locked() {
-        return this._annotationFlags.locked;
+        return this.flags_.locked;
     }
     set locked(value) {
-        this._annotationFlags.locked = value;
+        this.flags_.locked = value;
     }
     get appearanceStreamDict() {
         const apDict = this.content.get('AP')?.as(PdfDictionary);
@@ -103,4 +111,7 @@ export class PdfAnnotation extends PdfIndirectObject {
             this.content.set('P', ref);
         }
     }
+    get page() {
+        return this.parentRef?.resolve(PdfPage) ?? null;
+    }
 }

package/dist/annotations/pdf-default-resources.d.ts

@@ -0,0 +1,11 @@
+import { PdfArray, PdfDictionary } from '../core';
+export declare class PdfDefaultResourcesDictionary extends PdfDictionary<{
+    Font?: PdfDictionary;
+    ProcSet?: PdfArray;
+    ExtGState?: PdfDictionary;
+    ColorSpace?: PdfDictionary;
+    Pattern?: PdfDictionary;
+    Shading?: PdfDictionary;
+    XObject?: PdfDictionary;
+}> {
+}

package/dist/annotations/pdf-default-resources.js

@@ -0,0 +1,3 @@
+import { PdfDictionary } from '../core';
+export class PdfDefaultResourcesDictionary extends PdfDictionary {
+}

package/dist/core/decoder.js

@@ -286,7 +286,7 @@ export class PdfDecoder extends IncrementalParser {
             throw new Error('Trailer token missing byte offset');
         }
         trailer.offset.update(trailerToken.byteOffset);
-        trailer.offset.isModified = false;
+        trailer.offset.modified = false;
         trailer.preTokens = preTokens;
         trailer.postTokens = postTokens;
         return trailer;

package/dist/core/objects/pdf-array.d.ts

@@ -1,13 +1,20 @@
+import { PdfObjectReference } from '../index.js';
 import { PdfWhitespaceToken } from '../tokens/whitespace-token.js';
+import { PdfIndirectObject } from './pdf-indirect-object.js';
 import { PdfObject } from './pdf-object.js';
-export declare class PdfArray<T extends PdfObject = PdfObject> extends PdfObject {
+export declare class PdfArray<T extends PdfObject = PdfObject> extends PdfObject implements Iterable<T> {
     items: T[];
     innerTokens: PdfWhitespaceToken[];
     constructor(items?: T[]);
+    static refs(items: PdfIndirectObject[]): PdfArray<PdfObjectReference>;
     get length(): number;
     push(item: T): void;
+    get isTrailingDelimited(): boolean;
     protected tokenize(): import("../index.js").PdfToken[];
     cloneImpl(): this;
+    setModified(modified?: boolean): void;
     isModified(): boolean;
     setImmutable(immutable?: boolean): void;
+    refs(): PdfArray<PdfObjectReference>;
+    [Symbol.iterator](): Iterator<T>;
 }

package/dist/core/objects/pdf-array.js

@@ -1,6 +1,8 @@
+import { needsCentralWhitespace } from '../../utils/needsCentralWhitespace.js';
 import { PdfEndArrayToken } from '../tokens/end-array-token.js';
 import { PdfStartArrayToken } from '../tokens/start-array-token.js';
 import { PdfWhitespaceToken } from '../tokens/whitespace-token.js';
+import { PdfIndirectObject } from './pdf-indirect-object.js';
 import { PdfObject } from './pdf-object.js';
 export class PdfArray extends PdfObject {
     items;
@@ -9,12 +11,18 @@ export class PdfArray extends PdfObject {
         super();
         this.items = items;
     }
+    static refs(items) {
+        return new PdfArray(items.map((item) => item.reference));
+    }
     get length() {
         return this.items.length;
     }
     push(item) {
         this.items.push(item);
     }
+    get isTrailingDelimited() {
+        return true;
+    }
     tokenize() {
         const items = this.items.flatMap((item, index) => {
             const tokens = item.toTokens();
@@ -24,6 +32,11 @@ export class PdfArray extends PdfObject {
                     ? [PdfWhitespaceToken.SPACE]
                     : [];
             const postTokens = item.postTokens ? [] : [PdfWhitespaceToken.SPACE];
+            if (index !== this.items.length - 1 &&
+                postTokens.length === 0 &&
+                needsCentralWhitespace(item, this.items[index + 1])) {
+                postTokens.push(PdfWhitespaceToken.SPACE);
+            }
             return [...preTokens, ...tokens, ...postTokens];
         });
         return [
@@ -37,6 +50,10 @@ export class PdfArray extends PdfObject {
         const cloned = new PdfArray(this.items.map((x) => x.clone()));
         return cloned;
     }
+    setModified(modified) {
+        super.setModified(modified);
+        this.items.forEach((item) => item.setModified(modified));
+    }
     isModified() {
         return (super.isModified() || this.items.some((item) => item.isModified()));
     }
@@ -44,4 +61,18 @@ export class PdfArray extends PdfObject {
         super.setImmutable(immutable);
         this.items.forEach((item) => item.setImmutable(immutable));
     }
+    refs() {
+        const refs = this.items.map((item) => {
+            if (item instanceof PdfIndirectObject) {
+                return item.reference;
+            }
+            else {
+                throw new Error('Cannot get reference of non-indirect object in array');
+            }
+        });
+        return new PdfArray(refs);
+    }
+    [Symbol.iterator]() {
+        return this.items[Symbol.iterator]();
+    }
 }

package/dist/core/objects/pdf-dictionary.d.ts

@@ -20,9 +20,11 @@ export declare class PdfDictionary<T extends PdfDictionaryEntries = PdfDictionar
      * Each entry is a tuple of [key string, value].
      */
     entries(): IterableIterator<[string, PdfObject | undefined]>;
+    get isTrailingDelimited(): boolean;
     protected tokenize(): PdfToken[];
     copyFrom(other: PdfDictionary<any>): void;
     cloneImpl(): this;
+    setModified(modified?: boolean): void;
     isModified(): boolean;
     setImmutable(immutable?: boolean): void;
 }

package/dist/core/objects/pdf-dictionary.js

@@ -1,3 +1,4 @@
+import { needsCentralWhitespace } from '../../utils/needsCentralWhitespace.js';
 import { PdfEndDictionaryToken } from '../tokens/end-dictionary-token.js';
 import { PdfStartDictionaryToken } from '../tokens/start-dictionary-token.js';
 import { PdfWhitespaceToken } from '../tokens/whitespace-token.js';
@@ -11,7 +12,7 @@ export class PdfDictionary extends PdfObject {
         this.#entries = entries instanceof Map ? entries : new Map();
         if (entries) {
             for (const [key, value] of Object.entries(entries)) {
-                this.#entries.set(new PdfName(key), value);
+                this.set(key, value);
             }
         }
     }
@@ -28,9 +29,6 @@ export class PdfDictionary extends PdfObject {
         }
     }
     set(key, value) {
-        if (this.isImmutable()) {
-            throw new Error('Cannot modify an immutable PdfDictionary');
-        }
         const currentValue = this.get(key);
         if (currentValue !== value && !currentValue?.equals(value)) {
             this.modified = true;
@@ -50,9 +48,6 @@ export class PdfDictionary extends PdfObject {
         this.#entries.set(new PdfName(key), value);
     }
     delete(key) {
-        if (this.isImmutable()) {
-            throw new Error('Cannot modify an immutable PdfDictionary');
-        }
         if (this.has(key)) {
             this.modified = true;
         }
@@ -97,6 +92,9 @@ export class PdfDictionary extends PdfObject {
         const entries = Array.from(this.#entries.entries()).map(([key, value]) => [key.value, value]);
         return entries[Symbol.iterator]();
     }
+    get isTrailingDelimited() {
+        return true;
+    }
     tokenize() {
         let index = 0;
         const entries = Array.from(this.#entries.entries()).flatMap(([key, value]) => {
@@ -114,6 +112,9 @@ export class PdfDictionary extends PdfObject {
             const postTokens = value.postTokens
                 ? []
                 : [PdfWhitespaceToken.SPACE];
+            if (needsCentralWhitespace(key, value)) {
+                centralTokens.push(PdfWhitespaceToken.SPACE);
+            }
             index++;
             return [
                 ...preTokens,
@@ -144,6 +145,12 @@ export class PdfDictionary extends PdfObject {
         const cloned = new PdfDictionary(clonedEntries);
         return cloned;
     }
+    setModified(modified) {
+        super.setModified(modified);
+        for (const value of this.#entries.values()) {
+            value?.setModified(modified);
+        }
+    }
     isModified() {
         return (super.isModified() ||
             Array.from(this.#entries.values()).some((v) => v?.isModified()));

package/dist/core/objects/pdf-hexadecimal.d.ts

@@ -19,6 +19,7 @@ export declare class PdfHexadecimal extends PdfObject {
     get bytes(): ByteArray;
     toHexBytes(): ByteArray;
     toHexString(): string;
+    get isTrailingDelimited(): boolean;
     protected tokenize(): PdfHexadecimalToken[];
     cloneImpl(): this;
 }

package/dist/core/objects/pdf-hexadecimal.js

@@ -31,9 +31,6 @@ export class PdfHexadecimal extends PdfObject {
         return this._raw;
     }
     set raw(raw) {
-        if (this.isImmutable()) {
-            throw new Error('Cannot modify an immutable PdfHexadecimal');
-        }
         this.setModified();
         this._raw = raw;
         // Clear original bytes when modified
@@ -51,6 +48,9 @@ export class PdfHexadecimal extends PdfObject {
     toHexString() {
         return bytesToString(this.toHexBytes());
     }
+    get isTrailingDelimited() {
+        return true;
+    }
     tokenize() {
         return [new PdfHexadecimalToken(this.raw, this._originalBytes)];
     }

package/dist/core/objects/pdf-indirect-object.d.ts

@@ -2,20 +2,25 @@ import { PdfNull } from './pdf-null.js';
 import { PdfObject } from './pdf-object.js';
 import { PdfObjectReference } from './pdf-object-reference.js';
 import { Ref } from '../ref.js';
-export declare class PdfIndirectObject<T extends PdfObject = PdfObject> extends PdfObjectReference {
+export type PdfIndirectObjectOptions<T extends PdfObject = PdfObject> = {
+    objectNumber?: number;
+    generationNumber?: number;
+    content?: T;
+    offset?: number | Ref<number>;
+    encryptable?: boolean;
+    compressed?: boolean;
+} | T | PdfIndirectObject | undefined;
+export declare class PdfIndirectObject<T extends PdfObject = PdfObject> extends PdfObject {
     static readonly MAX_ORDER_INDEX = 2147483647;
+    objectNumber: number;
+    generationNumber: number;
     content: T;
     offset: Ref<number>;
     encryptable?: boolean;
+    compressed?: boolean;
     orderIndex?: number;
-    constructor(options?: {
-        objectNumber?: number;
-        generationNumber?: number;
-        content?: T;
-        offset?: number | Ref<number>;
-        encryptable?: boolean;
-    } | T | PdfIndirectObject);
-    get reference(): PdfObjectReference;
+    constructor(options?: PdfIndirectObjectOptions<T>);
+    get reference(): PdfObjectReference<this>;
     isEncryptable(): boolean;
     static createPlaceholder<T extends PdfObject>(objectNumber?: number, generationNumber?: number, content?: T): PdfIndirectObject<T extends unknown ? PdfNull : T>;
     inPdf(): boolean;
@@ -24,6 +29,10 @@ export declare class PdfIndirectObject<T extends PdfObject = PdfObject> extends
     copyFrom(other: PdfIndirectObject): void;
     cloneImpl(): this;
     order(): number;
+    setModified(modified?: boolean): void;
     isModified(): boolean;
     setImmutable(immutable?: boolean): void;
+    becomes<T extends PdfIndirectObject>(cls: new (options: PdfIndirectObject) => T): T;
+    resolve<T extends PdfIndirectObject>(cls?: new (options: PdfIndirectObject) => T): T;
+    get key(): string;
 }

package/dist/core/objects/pdf-indirect-object.js

@@ -7,46 +7,68 @@ import { PdfObjectReference } from './pdf-object-reference.js';
 import { PdfStream } from './pdf-stream.js';
 import { Ref } from '../ref.js';
 import { PdfByteOffsetToken } from '../tokens/byte-offset-token.js';
-export class PdfIndirectObject extends PdfObjectReference {
+export class PdfIndirectObject extends PdfObject {
     static MAX_ORDER_INDEX = 2147483647;
+    objectNumber;
+    generationNumber;
     content;
     offset;
     encryptable;
+    compressed;
     orderIndex;
     constructor(options) {
         if (options instanceof PdfIndirectObject) {
-            super(options.objectNumber, options.generationNumber);
-            this.content = options.content.clone();
-            this.offset = options.offset.clone();
+            super();
+            this.objectNumber = options.objectNumber;
+            this.generationNumber = options.generationNumber;
+            this.content = options.content;
+            this.offset = options.offset;
+            this.compressed = options.compressed;
             return;
         }
         if (options instanceof PdfObject) {
-            super(-1, 0);
+            super();
+            this.objectNumber = -1;
+            this.generationNumber = 0;
             this.content = options;
             this.offset = new Ref(0);
             return;
         }
-        super(options?.objectNumber ?? -1, options?.generationNumber ?? 0);
+        super();
+        this.objectNumber = options?.objectNumber ?? -1;
+        this.generationNumber = options?.generationNumber ?? 0;
         this.content = options?.content ?? new PdfNull();
         this.offset =
             options?.offset instanceof Ref
                 ? options.offset
                 : new Ref(options?.offset ?? 0);
         this.encryptable = options?.encryptable;
+        this.compressed = options?.compressed;
     }
     get reference() {
-        return new Proxy(this, {
-            get: (target, prop) => {
-                const value = new PdfObjectReference(target.objectNumber, target.generationNumber);
-                if (prop === 'objectNumber') {
-                    return target.objectNumber;
+        const original = this;
+        return new Proxy(new PdfObjectReference(this.objectNumber, this.generationNumber), {
+            get: (_target, prop) => {
+                // Always read from the live indirect object so objectNumber
+                // stays current even after the object is added to a document.
+                if (prop === 'resolve') {
+                    return original.resolve.bind(original);
                 }
-                else if (prop === 'generationNumber') {
-                    return target.generationNumber;
+                else if (prop === 'resolver') {
+                    // Signal that this proxy reference is resolvable
+                    // so collectMissingReferences can discover it
+                    return {
+                        resolve: () => original,
+                    };
+                }
+                else if (prop === 'objectNumber') {
+                    return original.objectNumber;
                 }
-                else {
-                    return value[prop];
+                else if (prop === 'generationNumber') {
+                    return original.generationNumber;
                 }
+                const value = new PdfObjectReference(original.objectNumber, original.generationNumber);
+                return value[prop];
             },
         });
     }
@@ -100,19 +122,56 @@ export class PdfIndirectObject extends PdfObjectReference {
             generationNumber: this.generationNumber,
             content: this.content.clone(),
             offset: this.offset.resolve(),
+            encryptable: this.encryptable,
+            compressed: this.compressed,
         });
     }
     order() {
         return this.orderIndex ?? 0;
     }
+    setModified(modified = true) {
+        super.setModified(modified);
+        this.content.setModified(modified);
+        this.offset.setModified(modified);
+    }
     isModified() {
         return (super.isModified() ||
             this.content.isModified() ||
-            this.offset.isModified);
+            this.offset.isModified());
     }
     setImmutable(immutable) {
         super.setImmutable(immutable);
         this.content.setImmutable(immutable);
         this.offset.setImmutable(immutable);
     }
+    becomes(cls) {
+        if (this instanceof cls) {
+            return this;
+        }
+        // Preserve identity-critical properties that subclass constructors
+        // may inadvertently reset (e.g. PdfFont's super() creates a fresh
+        // PdfIndirectObject with objectNumber = -1, and PdfFormField's
+        // super() chain creates a fresh empty PdfDictionary as content).
+        const savedObjectNumber = this.objectNumber;
+        const savedGenerationNumber = this.generationNumber;
+        const savedOffset = this.offset;
+        const savedContent = this.content;
+        const newObject = new cls(this);
+        Object.setPrototypeOf(this, cls.prototype);
+        Object.assign(this, newObject);
+        this.objectNumber = savedObjectNumber;
+        this.generationNumber = savedGenerationNumber;
+        this.offset = savedOffset;
+        this.content = savedContent;
+        return this;
+    }
+    resolve(cls) {
+        if (cls) {
+            return this.becomes(cls);
+        }
+        return this;
+    }
+    get key() {
+        return `${this.objectNumber}/${this.generationNumber}`;
+    }
 }

package/dist/core/objects/pdf-number.d.ts

@@ -18,6 +18,7 @@ export declare class PdfNumber extends PdfObject {
     toToken(): PdfNumberToken;
     protected tokenize(): PdfNumberToken[];
     cloneImpl(): this;
+    setModified(modified?: boolean): void;
     isModified(): boolean;
 }
 export declare class PdfByteOffsetNumber extends PdfNumber {

package/dist/core/objects/pdf-number.js

@@ -45,9 +45,6 @@ export class PdfNumber extends PdfObject {
         return this.#value.resolve();
     }
     set value(value) {
-        if (this.isImmutable()) {
-            throw new Error('Cannot modify an immutable PdfNumber');
-        }
         this.#value.update(value);
     }
     onChange(callback) {
@@ -72,8 +69,12 @@ export class PdfNumber extends PdfObject {
         });
         return cloned;
     }
+    setModified(modified) {
+        super.setModified(modified);
+        this.#value.setModified(modified);
+    }
     isModified() {
-        return super.isModified() || this.#value.isModified;
+        return super.isModified() || this.#value.isModified();
     }
 }
 export class PdfByteOffsetNumber extends PdfNumber {

package/dist/core/objects/pdf-object-reference.d.ts

@@ -1,9 +1,16 @@
 import { PdfToken } from '../tokens/token.js';
 import { PdfObject } from './pdf-object.js';
-export declare class PdfObjectReference extends PdfObject {
+import { PdfIndirectObject } from './pdf-indirect-object.js';
+export interface IPdfObjectResolver {
+    resolve(objectNumber: number, generationNumber: number): PdfIndirectObject;
+}
+export declare class PdfObjectReference<T extends PdfIndirectObject = PdfIndirectObject> extends PdfObject {
     objectNumber: number;
     generationNumber: number;
+    resolver?: IPdfObjectResolver;
     constructor(objectNumber: number, generationNumber: number);
     protected tokenize(): PdfToken[];
     cloneImpl(): this;
+    resolve<U extends PdfIndirectObject = T>(cls?: new (options: PdfIndirectObject) => U): U;
+    get key(): string;
 }

package/dist/core/objects/pdf-object-reference.js

@@ -3,6 +3,7 @@ import { PdfObject } from './pdf-object.js';
 export class PdfObjectReference extends PdfObject {
     objectNumber;
     generationNumber;
+    resolver;
     constructor(objectNumber, generationNumber) {
         super();
         this.objectNumber = objectNumber;
@@ -17,4 +18,17 @@ export class PdfObjectReference extends PdfObject {
         const cloned = new PdfObjectReference(this.objectNumber, this.generationNumber);
         return cloned;
     }
+    resolve(cls) {
+        if (!this.resolver) {
+            throw new Error(`No resolver set for PdfObjectReference '${this.objectNumber} ${this.generationNumber}'`);
+        }
+        const object = this.resolver.resolve(this.objectNumber, this.generationNumber);
+        if (cls) {
+            return object.becomes(cls);
+        }
+        return object;
+    }
+    get key() {
+        return `${this.objectNumber}/${this.generationNumber}`;
+    }
 }

package/dist/core/objects/pdf-object.d.ts

@@ -11,8 +11,16 @@ export declare abstract class PdfObject {
     protected immutable: boolean;
     /** Tokenizes the object into an array of PdfTokens */
     protected abstract tokenize(): PdfToken[];
+    /** Cached byte representation of the object, if available */
+    protected cachedTokens?: PdfToken[];
     /** The type of this PDF object */
     get objectType(): string;
+    /**
+     * Returns true if this object's serialized form ends with a self-delimiting
+     * character (e.g., `)`, `>`, `]`, `>>`). Such objects do not require trailing
+     * whitespace before the next token.
+     */
+    get isTrailingDelimited(): boolean;
     /** Indicates whether the object has been modified. Override this method if the modified state is determined differently */
     isModified(): boolean;
     /** Sets the modified state of the object. Override this method if the modified state is determined differently */
@@ -35,4 +43,10 @@ export declare abstract class PdfObject {
     clone(): this;
     /** Compares this object to another for equality based on their token representations */
     equals(other?: PdfObject): boolean;
+    /**
+     * Serializes the document to a Base64-encoded string.
+     *
+     * @returns A promise that resolves to the PDF document as a Base64 string
+     */
+    toBase64(): string;
 }