pdf-lite 1.0.1-alpha.2 → 1.0.1

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

@@ -0,0 +1,33 @@
+import { Ref } from '../ref';
+import { PdfByteOffsetToken } from '../tokens/byte-offset-token';
+import { PdfTrailerToken } from '../tokens/trailer-token';
+import { PdfWhitespaceToken } from '../tokens/whitespace-token';
+import { PdfDictionary } from './pdf-dictionary';
+import { PdfObject } from './pdf-object';
+export class PdfTrailer extends PdfObject {
+    dict;
+    offset = new Ref(0);
+    constructor(entries) {
+        super();
+        this.dict =
+            entries instanceof PdfDictionary
+                ? entries
+                : new PdfDictionary(entries);
+    }
+    tokenize() {
+        return [
+            new PdfByteOffsetToken(this.offset),
+            new PdfTrailerToken(),
+            ...(this.dict.preTokens ? [] : [PdfWhitespaceToken.NEWLINE]),
+            ...this.dict.toTokens(),
+        ];
+    }
+    clone() {
+        return new PdfTrailer(this.dict.clone());
+    }
+    isModified() {
+        return (super.isModified() ||
+            this.dict.isModified() ||
+            this.offset.isModified);
+    }
+}

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

@@ -0,0 +1,48 @@
+import { Ref } from '../ref';
+import { PdfXRefTableEntryToken } from '../tokens/xref-table-entry-token';
+import { PdfXRefTableSectionStartToken } from '../tokens/xref-table-section-start-token';
+import { PdfIndirectObject } from './pdf-indirect-object';
+import { PdfNumber } from './pdf-number';
+import { PdfObject } from './pdf-object';
+export declare class PdfXRefTableEntry extends PdfObject {
+    objectNumber: PdfNumber;
+    generationNumber: PdfNumber;
+    byteOffset: PdfNumber;
+    inUse: boolean;
+    constructor(options: {
+        byteOffset: number | PdfNumber | Ref<number>;
+        objectNumber: number | PdfNumber;
+        generationNumber: number | PdfNumber;
+        inUse: boolean;
+    });
+    protected tokenize(): PdfXRefTableEntryToken[];
+    clone(): this;
+    isModified(): boolean;
+}
+export declare class PdfXRefTableSectionHeader extends PdfObject {
+    startObjectNumber: PdfNumber;
+    entryCount: PdfNumber;
+    constructor(options: {
+        startObjectNumber: number | PdfNumber;
+        entryCount: number | PdfNumber;
+    });
+    protected tokenize(): PdfXRefTableSectionStartToken[];
+    clone(): this;
+}
+export declare class PdfXRefTable extends PdfObject {
+    sections: PdfXRefTableSectionHeader[];
+    entries: PdfXRefTableEntry[];
+    offset: Ref<number>;
+    constructor(options?: {
+        sections?: PdfXRefTableSectionHeader[];
+        entries?: PdfXRefTableEntry[];
+        offset?: Ref<number> | number;
+    });
+    isModified(): boolean;
+    addEntryForObject(obj: PdfIndirectObject): void;
+    getEntry(objectNumber: number): PdfXRefTableEntry | undefined;
+    get lastSection(): PdfXRefTableSectionHeader | null;
+    protected tokenize(): import("../tokens/token").PdfToken[];
+    private sortEntriesIntoSections;
+    clone(): this;
+}

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

@@ -0,0 +1,183 @@
+import { Ref } from '../ref';
+import { PdfByteOffsetToken } from '../tokens/byte-offset-token';
+import { PdfWhitespaceToken } from '../tokens/whitespace-token';
+import { PdfXRefTableEntryToken } from '../tokens/xref-table-entry-token';
+import { PdfXRefTableSectionStartToken } from '../tokens/xref-table-section-start-token';
+import { PdfXRefTableStartToken } from '../tokens/xref-table-start-token';
+import { PdfNumber } from './pdf-number';
+import { PdfObject } from './pdf-object';
+export class PdfXRefTableEntry extends PdfObject {
+    objectNumber;
+    generationNumber;
+    byteOffset;
+    inUse;
+    constructor(options) {
+        super();
+        this.byteOffset =
+            options.byteOffset instanceof PdfNumber
+                ? options.byteOffset
+                : new PdfNumber({
+                    value: options.byteOffset,
+                    padTo: 10,
+                });
+        this.byteOffset.isByteOffset = true;
+        this.objectNumber = new PdfNumber(options.objectNumber);
+        this.generationNumber =
+            options.generationNumber instanceof PdfNumber
+                ? options.generationNumber
+                : new PdfNumber({
+                    value: options.generationNumber,
+                    padTo: 5,
+                });
+        this.inUse = options.inUse;
+    }
+    tokenize() {
+        return [
+            new PdfXRefTableEntryToken(this.byteOffset.toToken(), this.generationNumber.toToken(), this.objectNumber.toToken(), this.inUse),
+        ];
+    }
+    clone() {
+        return new PdfXRefTableEntry({
+            byteOffset: this.byteOffset.clone(),
+            objectNumber: this.objectNumber.clone(),
+            generationNumber: this.generationNumber.clone(),
+            inUse: this.inUse,
+        });
+    }
+    isModified() {
+        return (super.isModified() ||
+            this.byteOffset.isModified() ||
+            this.objectNumber.isModified() ||
+            this.generationNumber.isModified());
+    }
+}
+export class PdfXRefTableSectionHeader extends PdfObject {
+    startObjectNumber;
+    entryCount;
+    constructor(options) {
+        super();
+        this.startObjectNumber = new PdfNumber(options.startObjectNumber);
+        this.entryCount = new PdfNumber(options.entryCount);
+    }
+    tokenize() {
+        return [
+            new PdfXRefTableSectionStartToken(this.startObjectNumber.value, this.entryCount.value),
+        ];
+    }
+    clone() {
+        return new PdfXRefTableSectionHeader({
+            startObjectNumber: this.startObjectNumber.clone(),
+            entryCount: this.entryCount.clone(),
+        });
+    }
+}
+export class PdfXRefTable extends PdfObject {
+    sections;
+    entries;
+    offset = new Ref(0);
+    constructor(options) {
+        super();
+        this.sections = options?.sections ?? [];
+        this.entries = options?.entries ?? [];
+        if (options?.offset) {
+            this.offset.update(options.offset);
+        }
+    }
+    isModified() {
+        return (super.isModified() ||
+            this.sections.some((section) => section.isModified()) ||
+            this.entries.some((entry) => entry.isModified()) ||
+            this.offset.isModified);
+    }
+    addEntryForObject(obj) {
+        const foundEntry = this.entries.find((entry) => entry.objectNumber.value === obj.objectNumber);
+        if (foundEntry) {
+            return;
+        }
+        const newEntry = new PdfXRefTableEntry({
+            objectNumber: obj.objectNumber,
+            generationNumber: obj.generationNumber,
+            byteOffset: obj.offset,
+            inUse: true,
+        });
+        this.entries.push(newEntry);
+    }
+    getEntry(objectNumber) {
+        return this.entries.find((entry) => entry.objectNumber.value === objectNumber);
+    }
+    get lastSection() {
+        if (this.sections.length === 0) {
+            return null;
+        }
+        return this.sections[this.sections.length - 1];
+    }
+    tokenize() {
+        const innerTokens = this.sortEntriesIntoSections().flatMap(({ section, entries }) => [
+            ...section.toTokens(),
+            ...entries.flatMap((entry) => entry.toTokens()),
+        ]);
+        for (let i = 0; i < innerTokens.length; i++) {
+            const previousToken = innerTokens[i - 1];
+            const currentToken = innerTokens[i];
+            // Only insert newline if previous token is not whitespace AND current token is not whitespace
+            const previousIsWhitespace = previousToken instanceof PdfWhitespaceToken;
+            const currentIsWhitespace = currentToken instanceof PdfWhitespaceToken;
+            if (!previousIsWhitespace && !currentIsWhitespace) {
+                innerTokens.splice(i, 0, PdfWhitespaceToken.NEWLINE);
+                i++; // Skip the newly inserted token
+            }
+        }
+        return [
+            new PdfByteOffsetToken(this.offset),
+            new PdfXRefTableStartToken(),
+            ...innerTokens,
+        ];
+    }
+    sortEntriesIntoSections() {
+        const sections = [];
+        let currentSection = null;
+        let currentEntries = [];
+        const sortedEntries = this.entries.sort((a, b) => a.objectNumber.value - b.objectNumber.value);
+        for (let i = 0; i < sortedEntries.length; i++) {
+            const last = i > 0 ? sortedEntries[i - 1] : null;
+            const entry = sortedEntries[i];
+            if (!last ||
+                entry.objectNumber.value !== last.objectNumber.value + 1) {
+                if (currentSection) {
+                    sections.push({
+                        section: currentSection,
+                        entries: currentEntries,
+                    });
+                }
+                currentSection =
+                    this.sections.find((x) => x.startObjectNumber.value ===
+                        entry.objectNumber.value) ??
+                        new PdfXRefTableSectionHeader({
+                            startObjectNumber: entry.objectNumber,
+                            entryCount: 1,
+                        });
+                currentEntries = [entry];
+            }
+            else {
+                currentEntries.push(entry);
+            }
+            if (currentSection) {
+                currentSection.entryCount.value = currentEntries.length;
+            }
+        }
+        if (currentSection) {
+            sections.push({
+                section: currentSection,
+                entries: currentEntries,
+            });
+        }
+        return sections;
+    }
+    clone() {
+        return new PdfXRefTable({
+            sections: this.sections.map((s) => s.clone()),
+            entries: this.entries.map((e) => e.clone()),
+            offset: new Ref(this.offset.resolve()),
+        });
+    }
+}

package/{packages/pdf-lite/src/core/parser.ts → dist/core/parser.d.ts}

@@ -5,18 +5,17 @@
  * @typeParam I - The input item type
  * @typeParam O - The output item type
  */
-export abstract class Parser<I, O> {
+export declare abstract class Parser<I, O> {
     /**
      * Feeds input items to the parser.
      *
      * @param input - Input items to process
      */
-    abstract feed(...input: I[]): void
-
+    abstract feed(...input: I[]): void;
     /**
      * Generates output items from the fed input.
      *
      * @returns A generator yielding output items
      */
-    abstract nextItems(): Generator<O>
+    abstract nextItems(): Generator<O>;
 }

package/dist/core/parser.js

@@ -0,0 +1,9 @@
+/**
+ * Abstract base class for parsers that transform input items to output items.
+ * Provides a common interface for feeding input and generating output.
+ *
+ * @typeParam I - The input item type
+ * @typeParam O - The output item type
+ */
+export class Parser {
+}

package/dist/core/ref.d.ts

@@ -0,0 +1,59 @@
+/**
+ * Callback function type for ref update notifications.
+ *
+ * @typeParam T - The value type of the ref
+ */
+export type RefUpdateCallback<T> = (oldValue: T, newValue: T) => void;
+/**
+ * A mutable reference wrapper that supports value updates and change notifications.
+ * Can hold a direct value or reference another Ref, forming reference chains.
+ *
+ * @typeParam T - The value type being referenced
+ *
+ * @example
+ * ```typescript
+ * const ref = new Ref(42)
+ * ref.onUpdate((old, newVal) => console.log(`Changed from ${old} to ${newVal}`))
+ * ref.update(100) // Logs: Changed from 42 to 100
+ * ```
+ */
+export declare class Ref<T> {
+    /** The current value or a reference to another Ref */
+    value: T | Ref<T>;
+    /** Registered callbacks for update notifications */
+    callbacks: Array<RefUpdateCallback<T>>;
+    isModified: boolean;
+    /**
+     * Creates a new Ref with an initial value.
+     *
+     * @param value - The initial value or another Ref to chain
+     * @throws Error if attempting to create a self-referencing Ref
+     */
+    constructor(value: T | Ref<T>);
+    /**
+     * Updates the reference to a new value or another Ref.
+     * Notifies all registered callbacks of the change.
+     *
+     * @param newValue - The new value or Ref to point to
+     */
+    update(newValue: T | Ref<T>): void;
+    /**
+     * Resolves the reference chain to get the final value.
+     *
+     * @returns The resolved value of type T
+     */
+    resolve(): T;
+    /**
+     * Compares this Ref's resolved value with another value or Ref.
+     *
+     * @param other - The value or Ref to compare against
+     * @returns True if the resolved values are equal
+     */
+    equals(other?: Ref<T> | T): boolean;
+    /**
+     * Registers a callback to be notified when the value changes.
+     *
+     * @param callback - The function to call on value updates
+     */
+    onUpdate(callback: RefUpdateCallback<T>): void;
+}

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

@@ -1,10 +1,3 @@
-/**
- * Callback function type for ref update notifications.
- *
- * @typeParam T - The value type of the ref
- */
-export type RefUpdateCallback<T> = (oldValue: T, newValue: T) => void
-
 /**
  * A mutable reference wrapper that supports value updates and change notifications.
  * Can hold a direct value or reference another Ref, forming reference chains.
@@ -18,85 +11,74 @@ export type RefUpdateCallback<T> = (oldValue: T, newValue: T) => void
  * ref.update(100) // Logs: Changed from 42 to 100
  * ```
  */
-export class Ref<T> {
+export class Ref {
     /** The current value or a reference to another Ref */
-    value: T | Ref<T>
+    value;
     /** Registered callbacks for update notifications */
-    callbacks: Array<RefUpdateCallback<T>> = []
-    isModified: boolean = false
-
+    callbacks = [];
+    isModified = false;
     /**
      * Creates a new Ref with an initial value.
      *
      * @param value - The initial value or another Ref to chain
      * @throws Error if attempting to create a self-referencing Ref
      */
-    constructor(value: T | Ref<T>) {
+    constructor(value) {
         if (value === this) {
-            throw new Error('Cannot create Ref to itself')
+            throw new Error('Cannot create Ref to itself');
         }
-        this.value = value
+        this.value = value;
     }
-
     /**
      * Updates the reference to a new value or another Ref.
      * Notifies all registered callbacks of the change.
      *
      * @param newValue - The new value or Ref to point to
      */
-    update(newValue: T | Ref<T>) {
+    update(newValue) {
         if (newValue === this) {
-            return
+            return;
         }
-
-        const resolvedNewValue =
-            newValue instanceof Ref ? newValue.resolve() : newValue
-
-        const oldValue = this.resolve()
+        const resolvedNewValue = newValue instanceof Ref ? newValue.resolve() : newValue;
+        const oldValue = this.resolve();
         if (oldValue !== resolvedNewValue) {
-            this.isModified = true
+            this.isModified = true;
         }
-
-        this.value = newValue
-        this.callbacks.forEach((cb) => cb(oldValue, this.resolve()))
+        this.value = newValue;
+        this.callbacks.forEach((cb) => cb(oldValue, this.resolve()));
     }
-
     /**
      * Resolves the reference chain to get the final value.
      *
      * @returns The resolved value of type T
      */
-    resolve(): T {
+    resolve() {
         if (this.value instanceof Ref) {
-            return this.value.resolve()
+            return this.value.resolve();
         }
-        return this.value
+        return this.value;
     }
-
     /**
      * Compares this Ref's resolved value with another value or Ref.
      *
      * @param other - The value or Ref to compare against
      * @returns True if the resolved values are equal
      */
-    equals(other?: Ref<T> | T): boolean {
+    equals(other) {
         if (other === undefined) {
-            return false
+            return false;
         }
-
         if (other instanceof Ref) {
-            return this.resolve() === other.resolve()
+            return this.resolve() === other.resolve();
         }
-
-        return this.resolve() === other
+        return this.resolve() === other;
     }
-
     /**
      * Registers a callback to be notified when the value changes.
      *
      * @param callback - The function to call on value updates
      */
-    onUpdate(callback: RefUpdateCallback<T>): void {
-        this.callbacks.push(callback)
+    onUpdate(callback) {
+        this.callbacks.push(callback);
     }
 }

package/dist/core/serializer.d.ts

@@ -0,0 +1,36 @@
+import { ByteArray } from '../types';
+import { Parser } from './parser';
+import { PdfToken } from './tokens/token';
+/**
+ * Serializes PDF tokens into a byte stream.
+ * Handles byte offset calculation and token serialization.
+ */
+export declare class PdfTokenSerializer extends Parser<PdfToken, number> {
+    /** Current byte offset in the output stream */
+    offset: number;
+    private buffer;
+    /**
+     * Feeds tokens into the serializer buffer.
+     *
+     * @param input - PDF tokens to serialize
+     */
+    feed(...input: PdfToken[]): void;
+    /**
+     * Generates bytes from the buffered tokens.
+     * Updates byte offset tokens as they are encountered.
+     *
+     * @returns A generator yielding individual bytes
+     */
+    nextItems(): Generator<number>;
+    /**
+     * Pre-calculates byte offsets for all byte offset tokens in the buffer.
+     * Does not consume the buffer.
+     */
+    calculateOffsets(): void;
+    /**
+     * Serializes all buffered tokens to a byte array.
+     *
+     * @returns The serialized PDF as a Uint8Array
+     */
+    toBytes(): ByteArray;
+}

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

@@ -1,68 +1,58 @@
-import { ByteArray } from '../types'
-import { Parser } from './parser'
-import { PdfByteOffsetToken } from './tokens/byte-offset-token'
-import { PdfToken } from './tokens/token'
-
+import { Parser } from './parser';
+import { PdfByteOffsetToken } from './tokens/byte-offset-token';
 /**
  * Serializes PDF tokens into a byte stream.
  * Handles byte offset calculation and token serialization.
  */
-export class PdfTokenSerializer extends Parser<PdfToken, number> {
+export class PdfTokenSerializer extends Parser {
     /** Current byte offset in the output stream */
-    offset: number = 0
-    private buffer: PdfToken[] = []
-
+    offset = 0;
+    buffer = [];
     /**
      * Feeds tokens into the serializer buffer.
      *
      * @param input - PDF tokens to serialize
      */
-    feed(...input: PdfToken[]): void {
-        this.buffer.push(...input)
+    feed(...input) {
+        this.buffer.push(...input);
     }
-
     /**
      * Generates bytes from the buffered tokens.
      * Updates byte offset tokens as they are encountered.
      *
      * @returns A generator yielding individual bytes
      */
-    *nextItems(): Generator<number> {
+    *nextItems() {
         while (this.buffer.length) {
-            const obj = this.buffer.shift()!
-
+            const obj = this.buffer.shift();
             if (obj instanceof PdfByteOffsetToken) {
-                obj.update(this.offset)
-                continue
+                obj.update(this.offset);
+                continue;
             }
-
-            const bytes = obj.toBytes()
-            yield* bytes
-            this.offset += bytes.length
+            const bytes = obj.toBytes();
+            yield* bytes;
+            this.offset += bytes.length;
         }
     }
-
     /**
      * Pre-calculates byte offsets for all byte offset tokens in the buffer.
      * Does not consume the buffer.
      */
-    calculateOffsets(): void {
-        let currentOffset = 0
-
+    calculateOffsets() {
+        let currentOffset = 0;
         for (const token of this.buffer) {
             if (token instanceof PdfByteOffsetToken) {
-                token.update(currentOffset)
+                token.update(currentOffset);
             }
-            currentOffset += token.toBytes().length
+            currentOffset += token.toBytes().length;
         }
     }
-
     /**
      * Serializes all buffered tokens to a byte array.
      *
      * @returns The serialized PDF as a Uint8Array
      */
-    toBytes(): ByteArray {
-        return new Uint8Array(Array.from(this.nextItems()))
+    toBytes() {
+        return new Uint8Array(Array.from(this.nextItems()));
     }
 }

package/dist/core/streams/object-stream.d.ts

@@ -0,0 +1,6 @@
+import { PdfObject } from '../objects/pdf-object';
+import { ByteArray } from '../../types';
+import { IterableReadableStream } from '../../utils/IterableReadableStream';
+export declare class PdfObjectStream extends IterableReadableStream<PdfObject> {
+    constructor(input: AsyncIterable<ByteArray> | Iterable<ByteArray>);
+}

package/dist/core/streams/object-stream.js

@@ -0,0 +1,15 @@
+import { IterableReadableStream } from '../../utils/IterableReadableStream';
+import { pdfDecoderAsync } from '../generators';
+export class PdfObjectStream extends IterableReadableStream {
+    constructor(input) {
+        super({
+            async start(controller) {
+                const decoder = pdfDecoderAsync(input);
+                for await (const obj of decoder) {
+                    controller.enqueue(obj);
+                }
+                controller.close();
+            },
+        });
+    }
+}