pdf-lite 1.0.1-alpha.2 → 1.0.1

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

@@ -0,0 +1,37 @@
+import { PdfObject } from '../core/objects/pdf-object';
+import { ByteArray } from '../types';
+import { PdfDocument } from './pdf-document';
+/**
+ * A reader for parsing PDF data into PdfDocument instances.
+ * Processes streams of PDF objects and constructs documents from them.
+ *
+ * @example
+ * ```typescript
+ * // Read PDF from file bytes
+ * const document = await PdfReader.fromBytes(fileBytes)
+ * ```
+ */
+export declare class PdfReader {
+    /** The stream of PDF objects to read from */
+    protected objectStream: AsyncIterable<PdfObject> | Iterable<PdfObject>;
+    /**
+     * Creates a new PdfReader instance.
+     *
+     * @param objectStream - An async or sync iterable of PDF objects
+     */
+    constructor(objectStream: AsyncIterable<PdfObject> | Iterable<PdfObject>);
+    /**
+     * Reads all objects from the stream and constructs a PdfDocument.
+     *
+     * @returns A promise that resolves to the parsed PdfDocument
+     */
+    read(): Promise<PdfDocument>;
+    /**
+     * Creates a PdfDocument directly from a byte stream.
+     * Convenience method that creates a reader internally.
+     *
+     * @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>;
+}

package/{packages/pdf-lite/src/pdf/pdf-reader.ts → dist/pdf/pdf-reader.js}

@@ -1,8 +1,5 @@
-import { PdfObject } from '../core/objects/pdf-object'
-import { PdfObjectStream } from '../core/streams/object-stream'
-import { ByteArray } from '../types'
-import { PdfDocument } from './pdf-document'
-
+import { PdfObjectStream } from '../core/streams/object-stream';
+import { PdfDocument } from './pdf-document';
 /**
  * A reader for parsing PDF data into PdfDocument instances.
  * Processes streams of PDF objects and constructs documents from them.
@@ -15,32 +12,27 @@ import { PdfDocument } from './pdf-document'
  */
 export class PdfReader {
     /** The stream of PDF objects to read from */
-    protected objectStream: AsyncIterable<PdfObject> | Iterable<PdfObject>
-
+    objectStream;
     /**
      * Creates a new PdfReader instance.
      *
      * @param objectStream - An async or sync iterable of PDF objects
      */
-    constructor(objectStream: AsyncIterable<PdfObject> | Iterable<PdfObject>) {
-        this.objectStream = objectStream
+    constructor(objectStream) {
+        this.objectStream = objectStream;
     }
-
     /**
      * Reads all objects from the stream and constructs a PdfDocument.
      *
      * @returns A promise that resolves to the parsed PdfDocument
      */
-    async read(): Promise<PdfDocument> {
-        const objects: PdfObject[] = []
-
+    async read() {
+        const objects = [];
         for await (const obj of this.objectStream) {
-            objects.push(obj)
+            objects.push(obj);
         }
-
-        return PdfDocument.fromObjects(objects)
+        return PdfDocument.fromObjects(objects);
     }
-
     /**
      * Creates a PdfDocument directly from a byte stream.
      * Convenience method that creates a reader internally.
@@ -48,10 +40,8 @@ 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: AsyncIterable<ByteArray> | Iterable<ByteArray>,
-    ): Promise<PdfDocument> {
-        const reader = new PdfReader(new PdfObjectStream(input))
-        return reader.read()
+    static async fromBytes(input) {
+        const reader = new PdfReader(new PdfObjectStream(input));
+        return reader.read();
     }
 }

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

@@ -0,0 +1,101 @@
+import { PdfDictionary } from '../core/objects/pdf-dictionary';
+import { PdfObject } from '../core/objects/pdf-object';
+import { PdfTrailerEntries } from '../core/objects/pdf-trailer';
+import { PdfToken } from '../core/tokens/token';
+import { PdfXrefLookup } from './pdf-xref-lookup';
+/**
+ * Represents a single revision of a PDF document.
+ * PDF documents can have multiple revisions for incremental updates,
+ * where each revision contains its own set of objects and cross-reference table.
+ */
+export declare class PdfRevision extends PdfObject {
+    /** Objects contained in this revision */
+    objects: PdfObject[];
+    /** Cross-reference lookup table for this revision */
+    xref: PdfXrefLookup;
+    /** Whether this revision is locked (cannot be modified) */
+    locked: boolean;
+    /**
+     * Creates a new PDF revision.
+     *
+     * @param options - Configuration options for the revision
+     * @param options.objects - Initial objects for this revision
+     * @param options.prev - Previous revision or xref lookup to link to
+     * @param options.locked - Whether the revision should be locked initially
+     */
+    constructor(options?: {
+        objects?: PdfObject[];
+        prev?: PdfXrefLookup | PdfRevision;
+        locked?: boolean;
+    });
+    /**
+     * Links this revision to a previous revision's cross-reference table.
+     *
+     * @param xref - The previous revision's xref lookup or revision
+     */
+    setPrev(xref: PdfXrefLookup | PdfRevision): void;
+    /**
+     * Checks if an object reference exists in this revision.
+     *
+     * @param object - The object to check for
+     * @returns True if the exact object instance exists in this revision
+     */
+    contains(object: PdfObject): boolean;
+    /**
+     * Checks if an equivalent object exists in this revision (by value equality).
+     *
+     * @param object - The object to check for
+     * @returns True if an equal object exists in this revision
+     */
+    exists(object: PdfObject): boolean;
+    /**
+     * Adds objects to the beginning of the revision's object list.
+     *
+     * @param objects - Objects to add at the beginning
+     */
+    unshift(...objects: PdfObject[]): void;
+    /**
+     * Adds objects to the revision.
+     *
+     * @param objects - Objects to add to the revision
+     */
+    addObject(...objects: PdfObject[]): void;
+    /**
+     * Adds an object at a specific position in the revision.
+     *
+     * @param object - The object to add
+     * @param index - Position to insert at (number) or object to insert before
+     * @throws Error if the revision is locked or index is out of bounds
+     */
+    addObjectAt(object: PdfObject, index?: number | PdfObject): void;
+    /**
+     * Removes objects from the revision.
+     *
+     * @param objects - Objects to remove from the revision
+     * @throws Error if the revision is locked
+     */
+    deleteObject(...objects: PdfObject[]): void;
+    isModified(): boolean;
+    /**
+     * Updates the revision by sorting objects and updating the xref table.
+     */
+    update(): void;
+    /**
+     * Sorts objects by their insertion order.
+     * Indirect objects are placed before other objects.
+     */
+    sortObjects(): void;
+    /**
+     * Gets the trailer dictionary for this revision.
+     *
+     * @returns The trailer dictionary containing document metadata references
+     */
+    get trailerDict(): PdfDictionary<PdfTrailerEntries>;
+    /**
+     * Creates a deep copy of this revision.
+     *
+     * @returns A cloned PdfRevision instance
+     */
+    clone(): this;
+    protected tokenize(): PdfToken[];
+}

package/{packages/pdf-lite/src/pdf/pdf-revision.ts → dist/pdf/pdf-revision.js}

@@ -1,11 +1,7 @@
-import { PdfDictionary } from '../core/objects/pdf-dictionary'
-import { PdfIndirectObject } from '../core/objects/pdf-indirect-object'
-import { PdfObject } from '../core/objects/pdf-object'
-import { PdfTrailerEntries } from '../core/objects/pdf-trailer'
-import { PdfToken } from '../core/tokens/token'
-import { PdfWhitespaceToken } from '../core/tokens/whitespace-token'
-import { PdfXrefLookup } from './pdf-xref-lookup'
-
+import { PdfIndirectObject } from '../core/objects/pdf-indirect-object';
+import { PdfObject } from '../core/objects/pdf-object';
+import { PdfWhitespaceToken } from '../core/tokens/whitespace-token';
+import { PdfXrefLookup } from './pdf-xref-lookup';
 /**
  * Represents a single revision of a PDF document.
  * PDF documents can have multiple revisions for incremental updates,
@@ -13,12 +9,11 @@ import { PdfXrefLookup } from './pdf-xref-lookup'
  */
 export class PdfRevision extends PdfObject {
     /** Objects contained in this revision */
-    objects: PdfObject[] = []
+    objects = [];
     /** Cross-reference lookup table for this revision */
-    xref: PdfXrefLookup
+    xref;
     /** Whether this revision is locked (cannot be modified) */
-    locked: boolean = false
-
+    locked = false;
     /**
      * Creates a new PDF revision.
      *
@@ -27,81 +22,71 @@ export class PdfRevision extends PdfObject {
      * @param options.prev - Previous revision or xref lookup to link to
      * @param options.locked - Whether the revision should be locked initially
      */
-    constructor(options?: {
-        objects?: PdfObject[]
-        prev?: PdfXrefLookup | PdfRevision
-        locked?: boolean
-    }) {
-        super()
-        this.modified = false
-        this.objects = options?.objects ?? []
-
-        this.xref = PdfXrefLookup.fromObjects(this.objects)
-
-        if (options?.prev) this.setPrev(options.prev)
+    constructor(options) {
+        super();
+        this.modified = false;
+        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.addObject(...this.xref.toTrailerSection());
+        this.locked = options?.locked ?? false;
     }
-
     /**
      * Links this revision to a previous revision's cross-reference table.
      *
      * @param xref - The previous revision's xref lookup or revision
      */
-    setPrev(xref: PdfXrefLookup | PdfRevision) {
-        xref = xref instanceof PdfRevision ? xref.xref : xref
-        this.xref.setPrev(xref)
+    setPrev(xref) {
+        xref = xref instanceof PdfRevision ? xref.xref : xref;
+        this.xref.setPrev(xref);
     }
-
     /**
      * Checks if an object reference exists in this revision.
      *
      * @param object - The object to check for
      * @returns True if the exact object instance exists in this revision
      */
-    contains(object: PdfObject): boolean {
-        return this.objects.includes(object)
+    contains(object) {
+        return this.objects.includes(object);
     }
-
     /**
      * Checks if an equivalent object exists in this revision (by value equality).
      *
      * @param object - The object to check for
      * @returns True if an equal object exists in this revision
      */
-    exists(object: PdfObject): boolean {
+    exists(object) {
         for (const obj of this.objects) {
             if (obj.equals(object)) {
-                return true
+                return true;
             }
         }
-        return false
+        return false;
     }
-
     /**
      * Adds objects to the beginning of the revision's object list.
      *
      * @param objects - Objects to add at the beginning
      */
-    unshift(...objects: PdfObject[]): void {
+    unshift(...objects) {
         for (const obj of objects.reverse()) {
-            this.objects.unshift(obj)
-            if (obj instanceof PdfIndirectObject) this.xref.addObject(obj)
+            this.objects.unshift(obj);
+            if (obj instanceof PdfIndirectObject)
+                this.xref.addObject(obj);
         }
     }
-
     /**
      * Adds objects to the revision.
      *
      * @param objects - Objects to add to the revision
      */
-    addObject(...objects: PdfObject[]): void {
+    addObject(...objects) {
         for (const obj of objects) {
-            this.addObjectAt(obj)
+            this.addObjectAt(obj);
         }
     }
-
     /**
      * Adds an object at a specific position in the revision.
      *
@@ -109,126 +94,106 @@ export class PdfRevision extends PdfObject {
      * @param index - Position to insert at (number) or object to insert before
      * @throws Error if the revision is locked or index is out of bounds
      */
-    addObjectAt(object: PdfObject, index?: number | PdfObject): void {
+    addObjectAt(object, index) {
         if (this.locked) {
-            throw new Error('Cannot add object to locked PDF revision')
+            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) {
-            throw new Error('Index out of bounds')
+            throw new Error('Index out of bounds');
         }
-
-        this.objects.splice(index, 0, object)
-        this.sortObjects()
-
+        this.objects.splice(index, 0, object);
+        this.sortObjects();
         if (object instanceof PdfIndirectObject) {
-            this.xref.addObject(object)
+            this.xref.addObject(object);
         }
-
-        this.update()
+        this.update();
     }
-
     /**
      * Removes objects from the revision.
      *
      * @param objects - Objects to remove from the revision
      * @throws Error if the revision is locked
      */
-    deleteObject(...objects: PdfObject[]): void {
+    deleteObject(...objects) {
         if (this.locked) {
-            throw new Error('Cannot delete object from locked PDF revision')
+            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
+                return;
             }
-
-            this.modified = true
-            this.objects.splice(index, 1)
-
+            this.modified = true;
+            this.objects.splice(index, 1);
             if (object instanceof PdfIndirectObject) {
-                this.xref.removeObject(object)
+                this.xref.removeObject(object);
             }
         }
     }
-
-    isModified(): boolean {
-        return (
-            super.isModified() ||
+    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(): void {
+    update() {
         if (this.locked) {
-            return
+            return;
         }
-        this.sortObjects()
-        this.xref.update()
-        this.modified = false
+        this.sortObjects();
+        this.xref.update();
+        this.modified = false;
     }
-
     /**
      * Sorts objects by their insertion order.
      * Indirect objects are placed before other objects.
      */
-    sortObjects(): void {
+    sortObjects() {
         this.objects.sort((a, b) => {
-            if (
-                a instanceof PdfIndirectObject &&
-                b instanceof PdfIndirectObject
-            ) {
-                return a.order() - b.order()
-            } else {
-                return 0
+            if (a instanceof PdfIndirectObject &&
+                b instanceof PdfIndirectObject) {
+                return a.order() - b.order();
             }
-        })
+            else {
+                return 0;
+            }
+        });
     }
-
     /**
      * Gets the trailer dictionary for this revision.
      *
      * @returns The trailer dictionary containing document metadata references
      */
-    get trailerDict(): PdfDictionary<PdfTrailerEntries> {
-        return this.xref.trailerDict
+    get trailerDict() {
+        return this.xref.trailerDict;
     }
-
     /**
      * Creates a deep copy of this revision.
      *
      * @returns A cloned PdfRevision instance
      */
-    clone(): this {
-        const clonedObjects = this.objects.map((obj) => obj.clone())
-        return new PdfRevision({ objects: clonedObjects }) as this
+    clone() {
+        const clonedObjects = this.objects.map((obj) => obj.clone());
+        return new PdfRevision({ objects: clonedObjects });
     }
-
-    protected tokenize(): PdfToken[] {
+    tokenize() {
         return this.objects.flatMap((obj) => [
             ...obj.toTokens(),
             PdfWhitespaceToken.NEWLINE,
-        ])
+        ]);
     }
 }

package/dist/pdf/pdf-xref-lookup.d.ts

@@ -0,0 +1,149 @@
+import { PdfObject } from '../core/objects/pdf-object';
+import { PdfIndirectObject } from '../core/objects/pdf-indirect-object';
+import { PdfXRefTable } from '../core/objects/pdf-xref-table';
+import { PdfTrailer, PdfTrailerEntries } from '../core/objects/pdf-trailer';
+import { PdfStream, PdfXRefStream, PdfXRefStreamEntry } from '../core/objects/pdf-stream';
+import { PdfDictionary } from '../core/objects/pdf-dictionary';
+import { Ref } from '../core/ref';
+/**
+ * Manages cross-reference (xref) lookup for PDF objects.
+ * Handles both traditional xref tables and xref streams, including hybrid documents.
+ * Supports linking multiple revisions through the Prev chain.
+ */
+export declare class PdfXrefLookup {
+    /** The underlying xref object (either a table or stream) */
+    object: PdfIndirectObject<PdfXRefStream> | PdfXRefTable;
+    /** Map of object numbers to their xref entries */
+    entries: Map<number, PdfXRefStreamEntry>;
+    /** Trailer dictionary containing document metadata references */
+    trailerDict: PdfDictionary<PdfTrailerEntries>;
+    /** Reference to the previous xref lookup in the revision chain */
+    prev?: PdfXrefLookup;
+    private type?;
+    private hybridXRefStream?;
+    /**
+     * Creates a new xref lookup instance.
+     *
+     * @param options - Configuration options
+     * @param options.type - Type of xref ('table' or 'stream')
+     * @param options.object - Pre-existing xref table or stream object
+     * @param options.trailerDict - Pre-existing trailer dictionary
+     * @param options.prev - Previous xref lookup to link to
+     */
+    constructor(options?: {
+        type?: 'table' | 'stream';
+        object?: PdfIndirectObject<PdfStream> | PdfXRefTable;
+        trailerDict?: PdfDictionary<PdfTrailerEntries>;
+        prev?: PdfXrefLookup;
+    });
+    /**
+     * Links this xref to a previous xref lookup.
+     * Copies missing trailer entries from the previous xref.
+     *
+     * @param xref - The previous xref lookup to link to
+     * @throws Error if trying to set self as previous (would create circular reference) or if offsets match (would create ambiguous or invalid xref chain)
+     */
+    setPrev(xref: PdfXrefLookup): void;
+    /**
+     * Sets the byte offset of the xref object.
+     */
+    set offset(value: Ref<number>);
+    /**
+     * Gets the byte offset of the xref object.
+     */
+    get offset(): Ref<number>;
+    /**
+     * Creates xref lookups from an array of PDF objects.
+     * Parses both xref tables and xref streams, linking them via the Prev chain.
+     *
+     * @param objects - Array of PDF objects to parse
+     * @returns The most recent xref lookup with linked previous lookups
+     */
+    static fromObjects(objects: PdfObject[]): PdfXrefLookup;
+    /**
+     * Creates an xref lookup from a traditional xref table and trailer.
+     * Handles hybrid xref documents with both table and stream entries.
+     *
+     * @param xrefTable - The xref table object
+     * @param trailer - The trailer object
+     * @param objects - Optional array of objects for resolving hybrid xref streams
+     * @returns A new PdfXrefLookup instance
+     */
+    static fromXrefTable(xrefTable: PdfXRefTable, trailer: PdfTrailer, objects?: PdfObject[]): PdfXrefLookup;
+    /**
+     * Creates an xref lookup from an xref stream object.
+     *
+     * @param streamObject - The indirect object containing the xref stream
+     * @returns A new PdfXrefLookup instance
+     */
+    static fromXrefStream(streamObject: PdfIndirectObject<PdfStream>): PdfXrefLookup;
+    /**
+     * Gets the size of the xref table (highest object number + 1).
+     * Ensures size is at least as large as the previous revision.
+     */
+    get size(): number;
+    /**
+     * Sets the size of the xref table.
+     */
+    set size(value: number);
+    /**
+     * Gets all xref entries as an array.
+     */
+    get entriesValues(): PdfXRefStreamEntry[];
+    /**
+     * Links xref entries to their corresponding indirect objects.
+     * Updates byte offset references to point to actual object offsets.
+     *
+     * @param objects - Array of indirect objects to link
+     */
+    linkIndirectObjects(objects: PdfIndirectObject[]): void;
+    /**
+     * Links this xref to a previous xref lookup based on the Prev trailer entry.
+     *
+     * @param objects - Array of xref lookups to search for the previous one
+     */
+    linkPrev(objects: PdfXrefLookup[]): void;
+    /**
+     * Updates the xref object with current entries.
+     * Handles both table and stream formats, including hybrid documents.
+     *
+     * @returns The updated xref object
+     */
+    update(): PdfIndirectObject<PdfXRefStream> | PdfXRefTable;
+    /**
+     * Adds an indirect object to the xref lookup.
+     * Assigns an object number if not already set.
+     *
+     * @param newObject - The indirect object to add
+     * @param options - Options for compressed objects
+     * @param options.parentObjectNumber - Object number of the containing object stream
+     * @param options.indexInStream - Index within the object stream
+     * @throws Error if trying to add compressed object with non-zero generation number
+     */
+    addObject(newObject: PdfIndirectObject, options?: {
+        parentObjectNumber?: number;
+        indexInStream?: number;
+    }): void;
+    /**
+     * Removes an indirect object from the xref lookup.
+     * Also removes any trailer references to the object.
+     *
+     * @param object - The indirect object to remove
+     */
+    removeObject(object: PdfIndirectObject): void;
+    /**
+     * Gets an xref entry by object number.
+     * Falls back to the previous xref if not found in current entries.
+     *
+     * @param objectNumber - The object number to look up
+     * @returns The xref entry or undefined if not found
+     */
+    getObject(objectNumber: number): PdfXRefStreamEntry | undefined;
+    /**
+     * Generates the trailer section objects for this xref.
+     * Includes xref table/stream, trailer (if using table), startxref, and EOF.
+     *
+     * @returns Array of objects forming the trailer section
+     */
+    toTrailerSection(): PdfObject[];
+}