pdf-lite 1.0.1-alpha.2 → 1.0.1

package/dist/core/incremental-parser.d.ts

@@ -0,0 +1,103 @@
+import { Parser } from './parser';
+/**
+ * Error thrown when the parser needs more input to continue parsing.
+ */
+export declare class NoMoreTokensError extends Error {
+}
+/**
+ * Error thrown when the end of file has been reached and no more input is available.
+ */
+export declare class EofReachedError extends Error {
+}
+/**
+ * Abstract base class for incremental parsers that can process input as it becomes available.
+ * Supports buffering, lookahead, and backtracking for complex parsing scenarios.
+ *
+ * @typeParam I - The input item type
+ * @typeParam O - The output item type
+ */
+export declare abstract class IncrementalParser<I, O> extends Parser<I, O> {
+    /** Current position in the input stream */
+    protected inputOffset: number;
+    /** Number of outputs generated */
+    protected outputOffset: number;
+    /** Buffer holding input items */
+    protected buffer: I[];
+    /** Current position in the buffer */
+    protected bufferIndex: number;
+    /** Whether end of file has been signaled */
+    eof: boolean;
+    /**
+     * Feeds input items into the parser buffer.
+     *
+     * @param input - Input items to add to the buffer
+     */
+    feed(...input: (I | I[])[]): void;
+    /**
+     * Checks if end of file has been reached and buffer is exhausted.
+     *
+     * @returns True if no more input is available
+     */
+    protected atEof(): boolean;
+    /**
+     * Peeks at an item in the buffer without consuming it.
+     *
+     * @param ahead - Number of positions to look ahead (default: 0)
+     * @returns The item at the peek position, or null if at EOF
+     * @throws NoMoreTokensError if more input is needed and EOF not signaled
+     */
+    protected peek(ahead?: number): I | null;
+    /**
+     * Consumes and returns the next item from the buffer.
+     *
+     * @returns The next item
+     * @throws NoMoreTokensError if more input is needed and EOF not signaled
+     * @throws EofReachedError if at EOF and no more items available
+     */
+    protected next(): I;
+    private expectValue;
+    /**
+     * Consumes and validates the next item against an expected type or value.
+     *
+     * @typeParam T - The expected item type
+     * @param itemType - Constructor or value to match against
+     * @returns The consumed item cast to the expected type
+     * @throws Error if the item doesn't match the expected type/value
+     */
+    protected expect<T extends I>(itemType: (new (...args: any[]) => T) | T): T;
+    /**
+     * Tries multiple parsing functions and returns the first successful result.
+     * Automatically backtracks on failure.
+     *
+     * @param fn - Array of parsing functions to try
+     * @returns The result from the first successful parsing function
+     * @throws NoMoreTokensError if any function needs more input
+     * @throws Error if all parsing functions fail
+     */
+    protected oneOf(...fn: (() => O)[]): O;
+    /**
+     * Compacts the buffer by removing consumed items
+     */
+    protected compact(): void;
+    /**
+     * Override to customize when to compact the buffer
+     * By default, compacts when more than 1000 items have been consumed
+     *
+     * @returns boolean indicating whether to compact the buffer
+     */
+    protected canCompact(): boolean;
+    /**
+     * Generates parsed output items from the buffer.
+     * Handles backtracking when more input is needed.
+     *
+     * @returns A generator yielding parsed output items
+     */
+    nextItems(): Generator<O>;
+    /**
+     * Abstract method to parse the next output item from the buffer.
+     * Subclasses must implement this to define parsing logic.
+     *
+     * @returns The parsed output item
+     */
+    protected abstract parse(): O;
+}

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

@@ -1,15 +1,14 @@
-import { Parser } from './parser'
-
+import { Parser } from './parser';
 /**
  * Error thrown when the parser needs more input to continue parsing.
  */
-export class NoMoreTokensError extends Error {}
-
+export class NoMoreTokensError extends Error {
+}
 /**
  * Error thrown when the end of file has been reached and no more input is available.
  */
-export class EofReachedError extends Error {}
-
+export class EofReachedError extends Error {
+}
 /**
  * Abstract base class for incremental parsers that can process input as it becomes available.
  * Supports buffering, lookahead, and backtracking for complex parsing scenarios.
@@ -17,48 +16,41 @@ export class EofReachedError extends Error {}
  * @typeParam I - The input item type
  * @typeParam O - The output item type
  */
-export abstract class IncrementalParser<I, O> extends Parser<I, O> {
+export class IncrementalParser extends Parser {
     /** Current position in the input stream */
-    protected inputOffset: number = 0
+    inputOffset = 0;
     /** Number of outputs generated */
-    protected outputOffset: number = 0
-
+    outputOffset = 0;
     /** Buffer holding input items */
-    protected buffer: I[] = []
+    buffer = [];
     /** Current position in the buffer */
-    protected bufferIndex: number = 0
-
+    bufferIndex = 0;
     /** Whether end of file has been signaled */
-    eof: boolean = false
-
+    eof = false;
     /**
      * Feeds input items into the parser buffer.
      *
      * @param input - Input items to add to the buffer
      */
-    feed(...input: (I | I[])[]): void {
+    feed(...input) {
         for (const item of input) {
             if (Array.isArray(item)) {
                 for (const subItem of item) {
-                    this.buffer.push(subItem)
+                    this.buffer.push(subItem);
                 }
-
-                continue
+                continue;
             }
-
-            this.buffer.push(item)
+            this.buffer.push(item);
         }
     }
-
     /**
      * Checks if end of file has been reached and buffer is exhausted.
      *
      * @returns True if no more input is available
      */
-    protected atEof(): boolean {
-        return this.eof && this.bufferIndex >= this.buffer.length
+    atEof() {
+        return this.eof && this.bufferIndex >= this.buffer.length;
     }
-
     /**
      * Peeks at an item in the buffer without consuming it.
      *
@@ -66,17 +58,16 @@ export abstract class IncrementalParser<I, O> extends Parser<I, O> {
      * @returns The item at the peek position, or null if at EOF
      * @throws NoMoreTokensError if more input is needed and EOF not signaled
      */
-    protected peek(ahead: number = 0): I | null {
-        const index = this.bufferIndex + ahead
+    peek(ahead = 0) {
+        const index = this.bufferIndex + ahead;
         if (index >= this.buffer.length) {
             if (!this.eof) {
-                throw new NoMoreTokensError('No more items available')
+                throw new NoMoreTokensError('No more items available');
             }
-            return null
+            return null;
         }
-        return this.buffer[index]
+        return this.buffer[index];
     }
-
     /**
      * Consumes and returns the next item from the buffer.
      *
@@ -84,43 +75,31 @@ export abstract class IncrementalParser<I, O> extends Parser<I, O> {
      * @throws NoMoreTokensError if more input is needed and EOF not signaled
      * @throws EofReachedError if at EOF and no more items available
      */
-    protected next(): I {
+    next() {
         if (this.bufferIndex >= this.buffer.length) {
             if (!this.eof) {
-                throw new NoMoreTokensError('No more items available')
+                throw new NoMoreTokensError('No more items available');
             }
-            throw new EofReachedError('End of file reached')
+            throw new EofReachedError('End of file reached');
         }
-        this.inputOffset++
-        return this.buffer[this.bufferIndex++]
+        this.inputOffset++;
+        return this.buffer[this.bufferIndex++];
     }
-
-    private expectValue<T extends I>(
-        value: I,
-        itemType: (new (...args: any[]) => T) | T,
-    ): T {
+    expectValue(value, itemType) {
         if (typeof itemType === 'function') {
             if (!(value instanceof itemType)) {
-                throw new Error(
-                    `[offset: ${this.inputOffset}] Expected ${itemType.name} but got ${value}`,
-                )
+                throw new Error(`[offset: ${this.inputOffset}] Expected ${itemType.name} but got ${value}`);
             }
-            return value as T
+            return value;
         }
-
         if (value !== itemType) {
-            const type =
-                typeof value === 'object'
-                    ? (value?.constructor.name ?? value)
-                    : value
-
-            throw new Error(
-                `[offset: ${this.inputOffset}] Expected ${itemType} but got ${type}`,
-            )
+            const type = typeof value === 'object'
+                ? (value?.constructor.name ?? value)
+                : value;
+            throw new Error(`[offset: ${this.inputOffset}] Expected ${itemType} but got ${type}`);
         }
-        return value as T
+        return value;
     }
-
     /**
      * Consumes and validates the next item against an expected type or value.
      *
@@ -129,13 +108,10 @@ export abstract class IncrementalParser<I, O> extends Parser<I, O> {
      * @returns The consumed item cast to the expected type
      * @throws Error if the item doesn't match the expected type/value
      */
-    protected expect<T extends I>(
-        itemType: (new (...args: any[]) => T) | T,
-    ): T {
-        const item = this.next()
-        return this.expectValue(item, itemType)
+    expect(itemType) {
+        const item = this.next();
+        return this.expectValue(item, itemType);
     }
-
     /**
      * Tries multiple parsing functions and returns the first successful result.
      * Automatically backtracks on failure.
@@ -145,77 +121,64 @@ export abstract class IncrementalParser<I, O> extends Parser<I, O> {
      * @throws NoMoreTokensError if any function needs more input
      * @throws Error if all parsing functions fail
      */
-    protected oneOf(...fn: (() => O)[]): O {
+    oneOf(...fn) {
         for (const f of fn) {
-            const savedOffset = this.inputOffset
-            const savedIndex = this.bufferIndex
-
+            const savedOffset = this.inputOffset;
+            const savedIndex = this.bufferIndex;
             try {
-                return f.bind(this)()
-            } catch (err) {
+                return f.bind(this)();
+            }
+            catch (err) {
                 if (err instanceof NoMoreTokensError) {
-                    throw err
+                    throw err;
                 }
-                this.inputOffset = savedOffset
-                this.bufferIndex = savedIndex
+                this.inputOffset = savedOffset;
+                this.bufferIndex = savedIndex;
             }
         }
-
-        throw new Error('No parsing function succeeded')
+        throw new Error('No parsing function succeeded');
     }
-
     /**
      * Compacts the buffer by removing consumed items
      */
-    protected compact(): void {
+    compact() {
         if (this.bufferIndex > 0) {
-            this.buffer = this.buffer.slice(this.bufferIndex)
-            this.bufferIndex = 0
+            this.buffer = this.buffer.slice(this.bufferIndex);
+            this.bufferIndex = 0;
         }
     }
-
     /**
      * Override to customize when to compact the buffer
      * By default, compacts when more than 1000 items have been consumed
      *
      * @returns boolean indicating whether to compact the buffer
      */
-    protected canCompact(): boolean {
-        return this.bufferIndex > 1000
+    canCompact() {
+        return this.bufferIndex > 1000;
     }
-
     /**
      * Generates parsed output items from the buffer.
      * Handles backtracking when more input is needed.
      *
      * @returns A generator yielding parsed output items
      */
-    *nextItems(): Generator<O> {
+    *nextItems() {
         while (!this.atEof()) {
-            const savedIndex = this.bufferIndex
-
+            const savedIndex = this.bufferIndex;
             try {
-                yield this.parse()
-                this.outputOffset++
-
+                yield this.parse();
+                this.outputOffset++;
                 if (this.canCompact()) {
-                    this.compact()
+                    this.compact();
                 }
-            } catch (err) {
+            }
+            catch (err) {
                 if (!(err instanceof NoMoreTokensError)) {
-                    throw err
+                    throw err;
                 }
-                this.bufferIndex = savedIndex
-                break
+                this.bufferIndex = savedIndex;
+                break;
             }
         }
     }
-
-    /**
-     * Abstract method to parse the next output item from the buffer.
-     * Subclasses must implement this to define parsing logic.
-     *
-     * @returns The parsed output item
-     */
-    protected abstract parse(): O
 }

package/dist/core/index.d.ts

@@ -0,0 +1,2 @@
+export * from './decoder.js';
+export * from './tokeniser.js';

package/dist/core/index.js

@@ -0,0 +1,2 @@
+export * from './decoder.js';
+export * from './tokeniser.js';

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

@@ -0,0 +1,12 @@
+import { PdfWhitespaceToken } from '../tokens/whitespace-token';
+import { PdfObject } from './pdf-object';
+export declare class PdfArray<T extends PdfObject = PdfObject> extends PdfObject {
+    items: T[];
+    innerTokens: PdfWhitespaceToken[];
+    constructor(items?: T[]);
+    get length(): number;
+    push(item: T): void;
+    protected tokenize(): import("../tokens/token").PdfToken[];
+    clone(): this;
+    isModified(): boolean;
+}

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

@@ -0,0 +1,42 @@
+import { PdfEndArrayToken } from '../tokens/end-array-token';
+import { PdfStartArrayToken } from '../tokens/start-array-token';
+import { PdfWhitespaceToken } from '../tokens/whitespace-token';
+import { PdfObject } from './pdf-object';
+export class PdfArray extends PdfObject {
+    items;
+    innerTokens = [];
+    constructor(items = []) {
+        super();
+        this.items = items;
+    }
+    get length() {
+        return this.items.length;
+    }
+    push(item) {
+        this.items.push(item);
+    }
+    tokenize() {
+        const items = this.items.flatMap((item, index) => {
+            const tokens = item.toTokens();
+            const preTokens = item.preTokens
+                ? []
+                : index === 0
+                    ? [PdfWhitespaceToken.SPACE]
+                    : [];
+            const postTokens = item.postTokens ? [] : [PdfWhitespaceToken.SPACE];
+            return [...preTokens, ...tokens, ...postTokens];
+        });
+        return [
+            new PdfStartArrayToken(),
+            ...this.innerTokens,
+            ...items,
+            new PdfEndArrayToken(),
+        ];
+    }
+    clone() {
+        return new PdfArray(this.items.map((x) => x.clone()));
+    }
+    isModified() {
+        return (super.isModified() || this.items.some((item) => item.isModified()));
+    }
+}

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

@@ -0,0 +1,8 @@
+import { PdfBooleanToken } from '../tokens/boolean-token';
+import { PdfObject } from './pdf-object';
+export declare class PdfBoolean extends PdfObject {
+    value: boolean;
+    constructor(value: boolean);
+    protected tokenize(): PdfBooleanToken[];
+    clone(): this;
+}

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

@@ -0,0 +1,15 @@
+import { PdfBooleanToken } from '../tokens/boolean-token';
+import { PdfObject } from './pdf-object';
+export class PdfBoolean extends PdfObject {
+    value;
+    constructor(value) {
+        super();
+        this.value = value;
+    }
+    tokenize() {
+        return [new PdfBooleanToken(this.value)];
+    }
+    clone() {
+        return new PdfBoolean(this.value);
+    }
+}

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

@@ -0,0 +1,18 @@
+import { ByteArray } from '../../types';
+import { PdfCommentToken } from '../tokens/comment-token';
+import { PdfObject } from './pdf-object';
+export declare class PdfComment extends PdfObject {
+    static EOF: PdfComment;
+    /**
+     * The comment value as raw bytes.
+     */
+    raw: ByteArray;
+    constructor(raw: string | ByteArray);
+    isEof(): boolean;
+    asString(): string;
+    isVersionComment(): boolean;
+    isEOFComment(): boolean;
+    static versionComment(version: string): PdfComment;
+    protected tokenize(): PdfCommentToken[];
+    clone(): this;
+}

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

@@ -0,0 +1,39 @@
+import { stringToBytes } from '../../utils/stringToBytes';
+import { PdfCommentToken } from '../tokens/comment-token';
+import { PdfWhitespaceToken } from '../tokens/whitespace-token';
+import { PdfObject } from './pdf-object';
+export class PdfComment extends PdfObject {
+    static EOF = new PdfComment('%EOF');
+    /**
+     * The comment value as raw bytes.
+     */
+    raw;
+    constructor(raw) {
+        super();
+        this.raw = typeof raw === 'string' ? stringToBytes(raw) : raw;
+    }
+    isEof() {
+        return this.equals(PdfComment.EOF);
+    }
+    asString() {
+        return new TextDecoder().decode(this.raw);
+    }
+    isVersionComment() {
+        const str = this.asString().toUpperCase();
+        return str.startsWith('PDF-');
+    }
+    isEOFComment() {
+        return this.equals(PdfComment.EOF);
+    }
+    static versionComment(version) {
+        const comment = new PdfComment(`PDF-${version}`);
+        comment.postTokens = [PdfWhitespaceToken.NEWLINE];
+        return comment;
+    }
+    tokenize() {
+        return [new PdfCommentToken(this.raw)];
+    }
+    clone() {
+        return new PdfComment(new Uint8Array(this.raw));
+    }
+}

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

@@ -0,0 +1,5 @@
+import { PdfString } from './pdf-string';
+export declare class PdfDate extends PdfString {
+    constructor(date: Date);
+    get date(): Date;
+}

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

@@ -0,0 +1,40 @@
+import { PdfString } from './pdf-string';
+export class PdfDate extends PdfString {
+    constructor(date) {
+        const pad = (n, width = 2) => n.toString().padStart(width, '0');
+        const year = date.getFullYear();
+        const month = pad(date.getMonth() + 1);
+        const day = pad(date.getDate());
+        const hours = pad(date.getHours());
+        const minutes = pad(date.getMinutes());
+        const seconds = pad(date.getSeconds());
+        const tzOffsetMinutes = -date.getTimezoneOffset(); // local to UTC
+        const sign = tzOffsetMinutes >= 0 ? '+' : '-';
+        const offsetHours = pad(Math.floor(Math.abs(tzOffsetMinutes) / 60));
+        const offsetMins = pad(Math.abs(tzOffsetMinutes) % 60);
+        const dateString = `D:${year}${month}${day}${hours}${minutes}${seconds}${sign}${offsetHours}'${offsetMins}'`;
+        super(dateString);
+    }
+    get date() {
+        const str = new TextDecoder().decode(this.raw);
+        const match = /^D:(\d{4})(\d{2})(\d{2})(\d{2})(\d{2})(\d{2})([+\-Z])?(\d{2})?'?(\d{2})?'?/.exec(str);
+        if (!match) {
+            throw new Error(`Invalid PDF date string: ${str}`);
+        }
+        const [, year, month, day, hours, minutes, seconds, tzSign, tzHours, tzMinutes,] = match;
+        let date = new Date(Date.UTC(parseInt(year), parseInt(month) - 1, parseInt(day), parseInt(hours), parseInt(minutes), parseInt(seconds)));
+        if (tzSign && tzSign !== 'Z') {
+            const offsetHours = parseInt(tzHours);
+            const offsetMinutes = parseInt(tzMinutes);
+            const totalOffsetMinutes = offsetHours * 60 + (isNaN(offsetMinutes) ? 0 : offsetMinutes);
+            const offsetMillis = totalOffsetMinutes * 60 * 1000;
+            if (tzSign === '+') {
+                date = new Date(date.getTime() - offsetMillis);
+            }
+            else if (tzSign === '-') {
+                date = new Date(date.getTime() + offsetMillis);
+            }
+        }
+        return date;
+    }
+}

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

@@ -0,0 +1,22 @@
+import { PdfToken } from '../tokens/token';
+import { PdfName } from './pdf-name';
+import { PdfObject } from './pdf-object';
+export type PdfDictionaryEntry = PdfObject | undefined;
+export type PdfDictionaryEntries = Record<string, PdfDictionaryEntry>;
+export type PdfDictionaryMap = Map<PdfName, PdfObject | undefined>;
+export declare class PdfDictionary<T extends PdfDictionaryEntries = PdfDictionaryEntries> extends PdfObject {
+    #private;
+    innerTokens: PdfToken[];
+    constructor(entries?: T | PdfDictionaryMap);
+    get<K extends Extract<keyof T, string>>(key: PdfName<K> | K): T[K] | undefined;
+    set<K extends Extract<keyof T, string>>(key: PdfName<K> | K, value: T[K]): void;
+    delete<K extends Extract<keyof T, string>>(key: PdfName<K> | K): void;
+    has<K extends Extract<keyof T, string>>(key: PdfName<K> | K): boolean;
+    get values(): {
+        readonly [K in Extract<keyof T, string>]: T[K];
+    };
+    protected tokenize(): PdfToken[];
+    copyFrom(other: PdfDictionary<any>): void;
+    clone(): this;
+    isModified(): boolean;
+}