pdf-lite 1.5.0 → 1.6.1

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

@@ -0,0 +1,50 @@
+import { PdfDictionary } from '../core/objects/pdf-dictionary.js';
+import { PdfArray } from '../core/objects/pdf-array.js';
+import { PdfObjectReference } from '../core/objects/pdf-object-reference.js';
+import { PdfIndirectObject } from '../core/objects/pdf-indirect-object.js';
+import { PdfNumber } from '../core/objects/pdf-number.js';
+import { PdfName } from '../core/objects/pdf-name.js';
+import { PdfPages } from './pdf-pages.js';
+type PdfPageDictionary = PdfDictionary<{
+    Type: PdfName<'Page'>;
+    Parent: PdfObjectReference;
+    MediaBox: PdfArray<PdfNumber>;
+    CropBox?: PdfArray<PdfNumber>;
+    BleedBox?: PdfArray<PdfNumber>;
+    TrimBox?: PdfArray<PdfNumber>;
+    ArtBox?: PdfArray<PdfNumber>;
+    Rotate?: PdfNumber;
+    Contents?: PdfObjectReference | PdfArray<PdfObjectReference>;
+    Resources?: PdfDictionary | PdfObjectReference;
+    Annots?: PdfArray<PdfObjectReference> | PdfObjectReference;
+}>;
+export declare class PdfPage extends PdfIndirectObject<PdfPageDictionary> {
+    constructor(options?: PdfIndirectObject);
+    private getBox;
+    private setBox;
+    get mediaBox(): [number, number, number, number];
+    set mediaBox(value: [number, number, number, number]);
+    get cropBox(): [number, number, number, number] | null;
+    set cropBox(value: [number, number, number, number] | null);
+    get bleedBox(): [number, number, number, number] | null;
+    set bleedBox(value: [number, number, number, number] | null);
+    get trimBox(): [number, number, number, number] | null;
+    set trimBox(value: [number, number, number, number] | null);
+    get artBox(): [number, number, number, number] | null;
+    set artBox(value: [number, number, number, number] | null);
+    get width(): number;
+    get height(): number;
+    get rotate(): number;
+    set rotate(value: number);
+    get contents(): PdfObjectReference | PdfArray<PdfObjectReference> | null;
+    set contents(value: PdfObjectReference | PdfArray<PdfObjectReference> | null);
+    get resources(): PdfDictionary | null;
+    set resources(value: PdfDictionary | PdfObjectReference | null);
+    get annotations(): PdfArray<PdfObjectReference>;
+    set annotations(value: PdfArray<PdfObjectReference>);
+    get parentRef(): PdfObjectReference;
+    set parentRef(value: PdfObjectReference);
+    get parent(): PdfPages;
+    set parent(value: PdfPages);
+}
+export {};

package/dist/pdf/pdf-page.js

@@ -0,0 +1,144 @@
+import { PdfDictionary } from '../core/objects/pdf-dictionary.js';
+import { PdfArray } from '../core/objects/pdf-array.js';
+import { PdfObjectReference } from '../core/objects/pdf-object-reference.js';
+import { PdfIndirectObject } from '../core/objects/pdf-indirect-object.js';
+import { PdfNumber } from '../core/objects/pdf-number.js';
+import { PdfPages } from './pdf-pages.js';
+export class PdfPage extends PdfIndirectObject {
+    constructor(options) {
+        super(options ??
+            new PdfIndirectObject({
+                content: new PdfDictionary(),
+            }));
+    }
+    getBox(name) {
+        const box = this.content.get(name)?.as((PdfArray));
+        if (!box || box.items.length < 4)
+            return null;
+        return [
+            box.items[0].value,
+            box.items[1].value,
+            box.items[2].value,
+            box.items[3].value,
+        ];
+    }
+    setBox(name, value) {
+        if (value === null) {
+            this.content.delete(name);
+        }
+        else {
+            this.content.set(name, new PdfArray(value.map((v) => new PdfNumber(v))));
+        }
+    }
+    get mediaBox() {
+        return this.getBox('MediaBox') ?? [0, 0, 612, 792];
+    }
+    set mediaBox(value) {
+        this.setBox('MediaBox', value);
+    }
+    get cropBox() {
+        return this.getBox('CropBox');
+    }
+    set cropBox(value) {
+        this.setBox('CropBox', value);
+    }
+    get bleedBox() {
+        return this.getBox('BleedBox');
+    }
+    set bleedBox(value) {
+        this.setBox('BleedBox', value);
+    }
+    get trimBox() {
+        return this.getBox('TrimBox');
+    }
+    set trimBox(value) {
+        this.setBox('TrimBox', value);
+    }
+    get artBox() {
+        return this.getBox('ArtBox');
+    }
+    set artBox(value) {
+        this.setBox('ArtBox', value);
+    }
+    get width() {
+        const box = this.mediaBox;
+        return box[2] - box[0];
+    }
+    get height() {
+        const box = this.mediaBox;
+        return box[3] - box[1];
+    }
+    get rotate() {
+        return this.content.get('Rotate')?.as(PdfNumber)?.value ?? 0;
+    }
+    set rotate(value) {
+        this.content.set('Rotate', new PdfNumber(value));
+    }
+    get contents() {
+        const entry = this.content.get('Contents');
+        if (!entry)
+            return null;
+        if (entry instanceof PdfArray)
+            return entry;
+        return entry.as(PdfObjectReference) ?? null;
+    }
+    set contents(value) {
+        if (value === null) {
+            this.content.delete('Contents');
+        }
+        else {
+            this.content.set('Contents', value);
+        }
+    }
+    get resources() {
+        const entry = this.content.get('Resources');
+        if (!entry)
+            return null;
+        if (entry instanceof PdfObjectReference) {
+            const resolved = entry.resolve();
+            if (resolved?.content instanceof PdfDictionary) {
+                return resolved.content;
+            }
+            return null;
+        }
+        return entry.as(PdfDictionary) ?? null;
+    }
+    set resources(value) {
+        if (value === null) {
+            this.content.delete('Resources');
+        }
+        else {
+            this.content.set('Resources', value);
+        }
+    }
+    get annotations() {
+        const entry = this.content.get('Annots');
+        if (entry instanceof PdfArray) {
+            return entry;
+        }
+        if (entry instanceof PdfObjectReference) {
+            const resolved = entry.resolve();
+            if (resolved?.content instanceof PdfArray) {
+                return resolved.content;
+            }
+        }
+        const newArray = new PdfArray();
+        this.content.set('Annots', newArray);
+        return newArray;
+    }
+    set annotations(value) {
+        this.content.set('Annots', value);
+    }
+    get parentRef() {
+        return this.content.get('Parent').as(PdfObjectReference);
+    }
+    set parentRef(value) {
+        this.content.set('Parent', value);
+    }
+    get parent() {
+        return this.parentRef.resolve(PdfPages);
+    }
+    set parent(value) {
+        this.parentRef = value.reference;
+    }
+}

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

@@ -0,0 +1,28 @@
+import { PdfDictionary } from '../core/objects/pdf-dictionary.js';
+import { PdfArray } from '../core/objects/pdf-array.js';
+import { PdfObjectReference } from '../core/objects/pdf-object-reference.js';
+import { PdfIndirectObject } from '../core/objects/pdf-indirect-object.js';
+import { PdfNumber } from '../core/objects/pdf-number.js';
+import { PdfName } from '../core/objects/pdf-name.js';
+import { PdfPage } from './pdf-page.js';
+type PdfPagesDictionary = PdfDictionary<{
+    Type: PdfName<'Pages'>;
+    Kids: PdfArray<PdfObjectReference>;
+    Count: PdfNumber;
+    Parent?: PdfObjectReference;
+}>;
+export declare class PdfPages extends PdfIndirectObject<PdfPagesDictionary> implements Iterable<PdfPage> {
+    constructor(options?: PdfIndirectObject);
+    get kids(): (PdfPage | PdfPages)[];
+    set kids(value: PdfArray<PdfObjectReference>);
+    get count(): number;
+    set count(value: number);
+    get parentRef(): PdfObjectReference | null;
+    set parentRef(value: PdfObjectReference | null);
+    get parent(): PdfPages | null;
+    set parent(value: PdfPages | null);
+    get(index: number): PdfPage;
+    toArray(): PdfPage[];
+    [Symbol.iterator](): Iterator<PdfPage>;
+}
+export {};

package/dist/pdf/pdf-pages.js

@@ -0,0 +1,94 @@
+import { PdfDictionary } from '../core/objects/pdf-dictionary.js';
+import { PdfArray } from '../core/objects/pdf-array.js';
+import { PdfObjectReference } from '../core/objects/pdf-object-reference.js';
+import { PdfIndirectObject } from '../core/objects/pdf-indirect-object.js';
+import { PdfNumber } from '../core/objects/pdf-number.js';
+import { PdfName } from '../core/objects/pdf-name.js';
+import { PdfPage } from './pdf-page.js';
+export class PdfPages extends PdfIndirectObject {
+    constructor(options) {
+        super(options ??
+            new PdfIndirectObject({
+                content: new PdfDictionary({
+                    Type: new PdfName('Pages'),
+                    Kids: new PdfArray(),
+                    Count: new PdfNumber(0),
+                }),
+            }));
+    }
+    get kids() {
+        const kidsArray = this.content
+            .get('Kids')
+            ?.as((PdfArray));
+        if (!kidsArray)
+            return [];
+        return kidsArray.items.map((ref) => {
+            const resolved = ref.as(PdfObjectReference).resolve();
+            const type = resolved.content
+                ?.as(PdfDictionary)
+                ?.get('Type')
+                ?.as(PdfName);
+            if (type?.value === 'Pages') {
+                return resolved.becomes(PdfPages);
+            }
+            return resolved.becomes(PdfPage);
+        });
+    }
+    set kids(value) {
+        this.content.set('Kids', value);
+    }
+    get count() {
+        return this.content.get('Count')?.as(PdfNumber)?.value ?? 0;
+    }
+    set count(value) {
+        this.content.set('Count', new PdfNumber(value));
+    }
+    get parentRef() {
+        return this.content.get('Parent')?.as(PdfObjectReference) ?? null;
+    }
+    set parentRef(value) {
+        if (value === null) {
+            this.content.delete('Parent');
+        }
+        else {
+            this.content.set('Parent', value);
+        }
+    }
+    get parent() {
+        const ref = this.parentRef;
+        if (!ref)
+            return null;
+        return ref.resolve(PdfPages);
+    }
+    set parent(value) {
+        this.parentRef = value?.reference ?? null;
+    }
+    get(index) {
+        return [...this][index];
+    }
+    toArray() {
+        return [...this];
+    }
+    *[Symbol.iterator]() {
+        const kidsArray = this.content
+            .get('Kids')
+            ?.as((PdfArray));
+        if (!kidsArray)
+            return;
+        for (const ref of kidsArray.items) {
+            const resolved = ref.as(PdfObjectReference)?.resolve();
+            if (!resolved)
+                continue;
+            const typeEntry = resolved.content
+                ?.as(PdfDictionary)
+                ?.get('Type')
+                ?.as(PdfName);
+            if (typeEntry?.value === 'Pages') {
+                yield* resolved.becomes(PdfPages);
+            }
+            else {
+                yield resolved.becomes(PdfPage);
+            }
+        }
+    }
+}

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

@@ -33,5 +33,9 @@ export declare class PdfReader {
      * @param input - Async or sync iterable of byte arrays
      * @returns A promise that resolves to the parsed PdfDocument
      */
-    static fromBytes(input: AsyncIterable<ByteArray> | Iterable<ByteArray>): Promise<PdfDocument>;
+    static fromBytes(input: AsyncIterable<ByteArray> | Iterable<ByteArray>, options?: {
+        password?: string;
+        ownerPassword?: string;
+        incremental?: boolean;
+    }): Promise<PdfDocument>;
 }

package/dist/pdf/pdf-reader.js

@@ -40,8 +40,42 @@ export class PdfReader {
      * @param input - Async or sync iterable of byte arrays
      * @returns A promise that resolves to the parsed PdfDocument
      */
-    static async fromBytes(input) {
+    static async fromBytes(input, options) {
         const reader = new PdfReader(new PdfObjectStream(input));
-        return reader.read();
+        const document = await reader.read();
+        let shouldDecrypt = Boolean(document.encryptionDictionary);
+        if (typeof options?.password === 'string') {
+            document.setPassword(options.password);
+            shouldDecrypt = true;
+        }
+        if (typeof options?.ownerPassword === 'string') {
+            document.setOwnerPassword(options.ownerPassword);
+            shouldDecrypt = true;
+        }
+        if (options?.incremental) {
+            // Lock revisions first to preserve the original bytes
+            // (including encrypted data) via cached tokens.
+            document.setIncremental(true);
+            // Then decrypt the live object data so built-in operations
+            // (AcroForm, fonts, etc.) can read it. The cached tokens
+            // still produce the original encrypted bytes on serialization.
+            if (shouldDecrypt) {
+                try {
+                    await document.decryptObjects();
+                }
+                catch (e) {
+                    document.resetSecurityHandler();
+                }
+            }
+        }
+        else if (shouldDecrypt) {
+            try {
+                await document.decryptObjects();
+            }
+            catch (e) {
+                document.resetSecurityHandler();
+            }
+        }
+        return document;
     }
 }

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

@@ -1,9 +1,9 @@
 import { PdfDictionary } from '../core/objects/pdf-dictionary.js';
+import { PdfIndirectObject } from '../core/objects/pdf-indirect-object.js';
 import { PdfObject } from '../core/objects/pdf-object.js';
 import { PdfTrailerEntries } from '../core/objects/pdf-trailer.js';
 import { PdfToken } from '../core/tokens/token.js';
 import { PdfComment } from '../index.js';
-import { ByteArray } from '../types.js';
 import { PdfXrefLookup } from './pdf-xref-lookup.js';
 /**
  * Represents a single revision of a PDF document.
@@ -17,7 +17,6 @@ export declare class PdfRevision extends PdfObject {
     private _locked;
     /** Cross-reference lookup table for this revision */
     xref: PdfXrefLookup;
-    private cachedBytes?;
     /**
      * Creates a new PDF revision.
      *
@@ -54,6 +53,7 @@ export declare class PdfRevision extends PdfObject {
      * @throws Error if the revision is locked
      */
     set objects(value: PdfObject[]);
+    get indirectObjects(): PdfIndirectObject[];
     /**
      * Links this revision to a previous revision's cross-reference table.
      *
@@ -126,5 +126,5 @@ export declare class PdfRevision extends PdfObject {
      */
     cloneImpl(): this;
     protected tokenize(): PdfToken[];
-    toBytes(): ByteArray;
+    isEmpty(): boolean;
 }

package/dist/pdf/pdf-revision.js

@@ -15,7 +15,6 @@ export class PdfRevision extends PdfObject {
     _locked = false;
     /** Cross-reference lookup table for this revision */
     xref;
-    cachedBytes;
     /**
      * Creates a new PDF revision.
      *
@@ -66,7 +65,6 @@ export class PdfRevision extends PdfObject {
      */
     set locked(value) {
         this._locked = value;
-        this.cachedBytes = value ? this.toBytes() : undefined;
         for (const obj of this._objects) {
             obj.setImmutable(value);
         }
@@ -89,6 +87,9 @@ export class PdfRevision extends PdfObject {
         }
         this._objects = value;
     }
+    get indirectObjects() {
+        return this._objects.filter((obj) => obj instanceof PdfIndirectObject);
+    }
     /**
      * Links this revision to a previous revision's cross-reference table.
      *
@@ -264,10 +265,9 @@ export class PdfRevision extends PdfObject {
         });
         return output;
     }
-    toBytes() {
-        if (this.cachedBytes) {
-            return this.cachedBytes;
-        }
-        return super.toBytes();
+    isEmpty() {
+        return (this.indirectObjects.length < 1 ||
+            (this.indirectObjects.length === 1 &&
+                this.indirectObjects[0] === this.xref.object));
     }
 }

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

@@ -77,14 +77,18 @@ export class PdfXrefLookup {
         this.prev = xref;
         const prevDict = xref.trailerDict;
         const dict = this.trailerDict;
-        !dict.has('Info') && dict.set('Info', prevDict.get('Info')?.clone());
-        !dict.has('Root') && dict.set('Root', prevDict.get('Root')?.clone());
-        !dict.has('Encrypt') &&
-            dict.set('Encrypt', prevDict.get('Encrypt')?.clone());
-        !dict.has('ID') && dict.set('ID', prevDict.get('ID')?.clone());
-        !dict.has('Prev') && dict.set('Prev', new PdfNumber(xref.offset));
-        const prev = dict.get('Prev');
-        if (prev) {
+        !dict.has('Info') && dict.set('Info', prevDict.get('Info'));
+        !dict.has('Root') && dict.set('Root', prevDict.get('Root'));
+        !dict.has('Encrypt') && dict.set('Encrypt', prevDict.get('Encrypt'));
+        !dict.has('ID') && dict.set('ID', prevDict.get('ID'));
+        if (!dict.has('Prev')) {
+            const prevNumber = new PdfNumber(xref.offset);
+            prevNumber.isByteOffset = true;
+            dict.set('Prev', prevNumber);
+        }
+        else {
+            const prev = dict.get('Prev');
+            prev.ref.update(xref.offset);
             prev.isByteOffset = true;
         }
     }
@@ -137,8 +141,18 @@ export class PdfXrefLookup {
         }
         const initialLookup = lookup;
         while (lookup) {
-            lookup.prev = lookups.find((x) => x.offset.equals(lookup?.trailerDict.get('Prev')?.value));
-            lookup = lookup.prev;
+            const prevEntry = lookup.trailerDict.get('Prev');
+            const prevLookup = lookups.find((x) => x.offset.equals(prevEntry?.value));
+            if (prevLookup) {
+                lookup.prev = prevLookup;
+                // Link the Prev entry's Ref to the previous xref's offset Ref
+                // so it automatically updates when positions change
+                if (prevEntry) {
+                    prevEntry.ref.update(prevLookup.offset);
+                    prevEntry.isByteOffset = true;
+                }
+            }
+            lookup = prevLookup;
         }
         return initialLookup;
     }
@@ -248,11 +262,11 @@ export class PdfXrefLookup {
      * @param objects - Array of xref lookups to search for the previous one
      */
     linkPrev(objects) {
-        const prevOffset = this.trailerDict.get('Prev')?.value;
-        if (prevOffset === undefined) {
+        const prevEntry = this.trailerDict.get('Prev');
+        if (prevEntry?.value === undefined) {
             return;
         }
-        const prevLookup = objects.filter((obj) => obj.offset.equals(prevOffset));
+        const prevLookup = objects.filter((obj) => obj.offset.equals(prevEntry.value));
         if (prevLookup.length === 0) {
             return;
         }
@@ -261,7 +275,10 @@ export class PdfXrefLookup {
         }
         if (prevLookup[0].offset.equals(0))
             return;
-        this.setPrev(prevLookup[0]);
+        this.prev = prevLookup[0];
+        // Link the Prev entry's Ref to the previous xref's offset Ref
+        prevEntry.ref.update(prevLookup[0].offset);
+        prevEntry.isByteOffset = true;
     }
     /**
      * Updates the xref object with current entries.
@@ -270,6 +287,9 @@ export class PdfXrefLookup {
      * @returns The updated xref object
      */
     update() {
+        if (this.object?.isImmutable()) {
+            return this.object;
+        }
         if (this.object instanceof PdfXRefTable) {
             const tableEntries = this.entriesValues.filter((entry) => entry instanceof PdfXRefTableEntry);
             const compressedEntries = this.entriesValues.filter((entry) => entry instanceof PdfXRefStreamCompressedEntry);

package/dist/signing/document-security-store.d.ts

@@ -6,7 +6,6 @@ import { PdfName } from '../core/objects/pdf-name.js';
 import { PdfObjectReference } from '../core/objects/pdf-object-reference.js';
 import { PdfStream } from '../core/objects/pdf-stream.js';
 import { PdfString } from '../core/objects/pdf-string.js';
-import { PdfDocument } from '../pdf/pdf-document.js';
 import { ByteArray } from '../types.js';
 import { RevocationInfo } from './types.js';
 /**
@@ -31,9 +30,9 @@ export declare class PdfOcspObject extends PdfIndirectObject<PdfStream> {
 export type PdfVriObject = PdfIndirectObject<PdfDictionary<{
     [CertHash: string]: PdfDictionary<{
         Type?: PdfName<'VRI'>;
-        Cert?: PdfObjectReference;
-        OCSP?: PdfObjectReference;
-        CRL?: PdfObjectReference;
+        Cert?: PdfObjectReference<PdfIndirectObject<PdfStream>>;
+        OCSP?: PdfObjectReference<PdfIndirectObject<PdfStream>>;
+        CRL?: PdfObjectReference<PdfIndirectObject<PdfStream>>;
         TU?: PdfDate;
         TS?: PdfString;
     }>;
@@ -45,9 +44,9 @@ export type PdfVriObject = PdfIndirectObject<PdfDictionary<{
 export declare class PdfDocumentSecurityStoreDictionary extends PdfDictionary<{
     Type?: PdfName<'DSS'>;
     VRI?: PdfObjectReference;
-    OCSPs?: PdfArray<PdfObjectReference>;
-    CRLs?: PdfArray<PdfObjectReference>;
-    Certs?: PdfArray<PdfObjectReference>;
+    OCSPs?: PdfArray<PdfObjectReference<PdfIndirectObject<PdfStream>>>;
+    CRLs?: PdfArray<PdfObjectReference<PdfIndirectObject<PdfStream>>>;
+    Certs?: PdfArray<PdfObjectReference<PdfIndirectObject<PdfStream>>>;
 }> {
 }
 /**
@@ -57,48 +56,46 @@ export declare class PdfDocumentSecurityStoreDictionary extends PdfDictionary<{
  * @example
  * ```typescript
  * const dss = new PdfDocumentSecurityStoreObject(document)
- * await dss.addCert(certificateBytes)
- * await dss.addCrl(crlBytes)
- * await dss.addOcsp(ocspBytes)
+ * dss.addCert(certificateBytes)
+ * dss.addCrl(crlBytes)
+ * dss.addOcsp(ocspBytes)
  * ```
  */
 export declare class PdfDocumentSecurityStoreObject extends PdfIndirectObject<PdfDocumentSecurityStoreDictionary> {
-    /** Reference to the parent document. */
-    private document;
     /**
      * Creates a new DSS object.
      *
      * @param document - The parent PDF document.
      * @param content - Optional pre-existing DSS dictionary.
      */
-    constructor(document: PdfDocument, content?: PdfDocumentSecurityStoreDictionary);
+    constructor(content?: PdfDocumentSecurityStoreDictionary);
     /**
      * Adds an OCSP response to the DSS, avoiding duplicates.
      *
      * @param ocsp - The DER-encoded OCSP response.
      * @returns The created or existing OCSP object.
      */
-    addOcsp(ocsp: ByteArray): Promise<PdfOcspObject>;
+    addOcsp(ocsp: ByteArray): PdfOcspObject;
     /**
      * Adds a CRL to the DSS, avoiding duplicates.
      *
      * @param crl - The DER-encoded CRL.
      * @returns The created or existing CRL object.
      */
-    addCrl(crl: ByteArray): Promise<PdfCrlObject>;
+    addCrl(crl: ByteArray): PdfCrlObject;
     /**
      * Adds a certificate to the DSS, avoiding duplicates.
      *
      * @param cert - The DER-encoded certificate.
      * @returns The created or existing certificate object.
      */
-    addCert(cert: ByteArray): Promise<PdfCertObject>;
+    addCert(cert: ByteArray): PdfCertObject;
     /**
      * Adds revocation information (CRLs and OCSPs) to the DSS.
      *
      * @param revocationInfo - The revocation information to add.
      */
-    addRevocationInfo(revocationInfo: RevocationInfo): Promise<void>;
+    addRevocationInfo(revocationInfo: RevocationInfo): void;
     /**
      * Checks if the DSS is empty (contains no certificates, CRLs, or OCSPs).
      *