pdf-lite 1.0.0

package/packages/pdf-lite/src/core/incremental-parser.ts

@@ -0,0 +1,221 @@
+import { Parser } from './parser'
+
+/**
+ * Error thrown when the parser needs more input to continue parsing.
+ */
+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 {}
+
+/**
+ * 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 abstract class IncrementalParser<I, O> extends Parser<I, O> {
+    /** Current position in the input stream */
+    protected inputOffset: number = 0
+    /** Number of outputs generated */
+    protected outputOffset: number = 0
+
+    /** Buffer holding input items */
+    protected buffer: I[] = []
+    /** Current position in the buffer */
+    protected bufferIndex: number = 0
+
+    /** Whether end of file has been signaled */
+    eof: boolean = false
+
+    /**
+     * Feeds input items into the parser buffer.
+     *
+     * @param input - Input items to add to the buffer
+     */
+    feed(...input: (I | I[])[]): void {
+        for (const item of input) {
+            if (Array.isArray(item)) {
+                for (const subItem of item) {
+                    this.buffer.push(subItem)
+                }
+
+                continue
+            }
+
+            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
+    }
+
+    /**
+     * 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 = 0): I | null {
+        const index = this.bufferIndex + ahead
+        if (index >= this.buffer.length) {
+            if (!this.eof) {
+                throw new NoMoreTokensError('No more items available')
+            }
+            return null
+        }
+        return this.buffer[index]
+    }
+
+    /**
+     * 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 {
+        if (this.bufferIndex >= this.buffer.length) {
+            if (!this.eof) {
+                throw new NoMoreTokensError('No more items available')
+            }
+            throw new EofReachedError('End of file reached')
+        }
+        this.inputOffset++
+        return this.buffer[this.bufferIndex++]
+    }
+
+    private expectValue<T extends I>(
+        value: I,
+        itemType: (new (...args: any[]) => T) | T,
+    ): T {
+        if (typeof itemType === 'function') {
+            if (!(value instanceof itemType)) {
+                throw new Error(
+                    `[offset: ${this.inputOffset}] Expected ${itemType.name} but got ${value}`,
+                )
+            }
+            return value as T
+        }
+
+        if (value !== itemType) {
+            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
+    }
+
+    /**
+     * 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 {
+        const item = this.next()
+        return this.expectValue(item, itemType)
+    }
+
+    /**
+     * 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 {
+        for (const f of fn) {
+            const savedOffset = this.inputOffset
+            const savedIndex = this.bufferIndex
+
+            try {
+                return f.bind(this)()
+            } catch (err) {
+                if (err instanceof NoMoreTokensError) {
+                    throw err
+                }
+                this.inputOffset = savedOffset
+                this.bufferIndex = savedIndex
+            }
+        }
+
+        throw new Error('No parsing function succeeded')
+    }
+
+    /**
+     * Compacts the buffer by removing consumed items
+     */
+    protected compact(): void {
+        if (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
+    }
+
+    /**
+     * Generates parsed output items from the buffer.
+     * Handles backtracking when more input is needed.
+     *
+     * @returns A generator yielding parsed output items
+     */
+    *nextItems(): Generator<O> {
+        while (!this.atEof()) {
+            const savedIndex = this.bufferIndex
+
+            try {
+                yield this.parse()
+                this.outputOffset++
+
+                if (this.canCompact()) {
+                    this.compact()
+                }
+            } catch (err) {
+                if (!(err instanceof NoMoreTokensError)) {
+                    throw err
+                }
+                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/packages/pdf-lite/src/core/index.ts

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

package/packages/pdf-lite/src/core/objects/pdf-array.ts

@@ -0,0 +1,54 @@
+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<T extends PdfObject = PdfObject> extends PdfObject {
+    items: T[]
+    innerTokens: PdfWhitespaceToken[] = []
+
+    constructor(items: T[] = []) {
+        super()
+        this.items = items
+    }
+
+    get length(): number {
+        return this.items.length
+    }
+
+    push(item: T) {
+        this.items.push(item)
+    }
+
+    protected 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(): this {
+        return new PdfArray(this.items.map((x) => x.clone())) as this
+    }
+
+    isModified(): boolean {
+        return (
+            super.isModified() || this.items.some((item) => item.isModified())
+        )
+    }
+}

package/packages/pdf-lite/src/core/objects/pdf-boolean.ts

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

package/packages/pdf-lite/src/core/objects/pdf-comment.ts

@@ -0,0 +1,50 @@
+import { ByteArray } from '../../types'
+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: ByteArray
+
+    constructor(raw: string | ByteArray) {
+        super()
+        this.raw = typeof raw === 'string' ? stringToBytes(raw) : raw
+    }
+
+    isEof(): boolean {
+        return this.equals(PdfComment.EOF)
+    }
+
+    asString() {
+        return new TextDecoder().decode(this.raw)
+    }
+
+    isVersionComment(): boolean {
+        const str = this.asString().toUpperCase()
+        return str.startsWith('PDF-')
+    }
+
+    isEOFComment() {
+        return this.equals(PdfComment.EOF)
+    }
+
+    static versionComment(version: string): PdfComment {
+        const comment = new PdfComment(`PDF-${version}`)
+        comment.postTokens = [PdfWhitespaceToken.NEWLINE]
+        return comment
+    }
+
+    protected tokenize() {
+        return [new PdfCommentToken(this.raw)]
+    }
+
+    clone(): this {
+        return new PdfComment(new Uint8Array(this.raw)) as this
+    }
+}

package/packages/pdf-lite/src/core/objects/pdf-date.ts

@@ -0,0 +1,74 @@
+import { PdfString } from './pdf-string'
+
+export class PdfDate extends PdfString {
+    constructor(date: Date) {
+        const pad = (n: number, width: number = 2): string =>
+            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(): 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/packages/pdf-lite/src/core/objects/pdf-dictionary.ts

@@ -0,0 +1,171 @@
+import { PdfEndDictionaryToken } from '../tokens/end-dictionary-token'
+import { PdfStartDictionaryToken } from '../tokens/start-dictionary-token'
+import { PdfToken } from '../tokens/token'
+import { PdfWhitespaceToken } from '../tokens/whitespace-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 class PdfDictionary<
+    T extends PdfDictionaryEntries = PdfDictionaryEntries,
+> extends PdfObject {
+    #entries: PdfDictionaryMap
+    innerTokens: PdfToken[] = []
+
+    constructor(entries?: T | PdfDictionaryMap) {
+        super()
+
+        this.#entries = entries instanceof Map ? entries : new Map<any, any>()
+        if (entries) {
+            for (const [key, value] of Object.entries(entries)) {
+                this.#entries.set(new PdfName(key), value)
+            }
+        }
+    }
+
+    get<K extends Extract<keyof T, string>>(
+        key: PdfName<K> | K,
+    ): T[K] | undefined {
+        if (key instanceof PdfName) {
+            return this.#entries.get(key) as T[K] | undefined
+        } else {
+            for (const [k, v] of this.#entries) {
+                if (k.value === key) {
+                    return v as T[K] | undefined
+                }
+            }
+        }
+    }
+
+    set<K extends Extract<keyof T, string>>(key: PdfName<K> | K, value: T[K]) {
+        const currentValue = this.get(key)
+        if (currentValue !== value && !currentValue?.equals(value)) {
+            this.modified = true
+        }
+
+        if (key instanceof PdfName) {
+            this.#entries.set(key, value)
+            return
+        } else {
+            for (const k of this.#entries.keys()) {
+                if (k.value === key) {
+                    this.#entries.set(k, value)
+                    return
+                }
+            }
+        }
+        this.#entries.set(new PdfName(key), value)
+    }
+
+    delete<K extends Extract<keyof T, string>>(key: PdfName<K> | K) {
+        if (this.has(key)) {
+            this.modified = true
+        }
+
+        if (key instanceof PdfName) {
+            this.#entries.delete(key)
+            return
+        } else {
+            for (const k of this.#entries.keys()) {
+                if (k.value === key) {
+                    this.#entries.delete(k)
+                    return
+                }
+            }
+        }
+    }
+
+    has<K extends Extract<keyof T, string>>(key: PdfName<K> | K): boolean {
+        if (key instanceof PdfName) {
+            return this.#entries.has(key)
+        } else {
+            for (const k of this.#entries.keys()) {
+                if (k.value === key) {
+                    return true
+                }
+            }
+        }
+        return false
+    }
+
+    get values(): {
+        readonly [K in Extract<keyof T, string>]: T[K]
+    } {
+        const obj: Partial<T> = {}
+        for (const [key, value] of this.#entries) {
+            obj[key.value as Extract<keyof T, string>] = value as T[Extract<
+                keyof T,
+                string
+            >]
+        }
+        return obj as T
+    }
+
+    protected tokenize() {
+        let index = 0
+
+        const entries = Array.from(this.#entries.entries()).flatMap(
+            ([key, value]) => {
+                if (value === undefined) {
+                    return []
+                }
+
+                const preTokens = key.preTokens
+                    ? []
+                    : index === 0
+                      ? [PdfWhitespaceToken.SPACE]
+                      : []
+
+                const centralTokens =
+                    key.postTokens || value.preTokens
+                        ? []
+                        : [PdfWhitespaceToken.SPACE]
+
+                const postTokens = value.postTokens
+                    ? []
+                    : [PdfWhitespaceToken.SPACE]
+
+                index++
+                return [
+                    ...preTokens,
+                    ...key.toTokens(),
+                    ...centralTokens,
+                    ...value.toTokens(),
+                    ...postTokens,
+                ]
+            },
+        )
+
+        return [
+            new PdfStartDictionaryToken(),
+            ...this.innerTokens,
+            ...entries,
+            new PdfEndDictionaryToken(),
+        ]
+    }
+
+    copyFrom(other: PdfDictionary<any>) {
+        for (const [key, value] of other.#entries) {
+            this.#entries.set(key, value)
+        }
+        this.modified = true
+    }
+
+    clone(): this {
+        const clonedEntries = new Map<PdfName, PdfObject | undefined>()
+        for (const [key, value] of this.#entries) {
+            clonedEntries.set(key.clone(), value ? value.clone() : undefined)
+        }
+        return new PdfDictionary(clonedEntries) as this
+    }
+
+    isModified(): boolean {
+        return (
+            super.isModified() ||
+            Array.from(this.#entries.values()).some((v) => v?.isModified())
+        )
+    }
+}

package/packages/pdf-lite/src/core/objects/pdf-hexadecimal.ts

@@ -0,0 +1,54 @@
+import { ByteArray } from '../../types'
+import { bytesToHexBytes } from '../../utils/bytesToHexBytes'
+import { bytesToString } from '../../utils/bytesToString'
+import { hexBytesToBytes } from '../../utils/hexBytesToBytes'
+import { stringToBytes } from '../../utils/stringToBytes'
+import { PdfHexadecimalToken } from '../tokens/hexadecimal-token'
+import { PdfObject } from './pdf-object'
+
+export class PdfHexadecimal extends PdfObject {
+    /**
+     * The raw byte value represented by this hexadecimal object.
+     * NB: This is  the hexadecimal representation, not the actual byte values.
+     */
+    raw: ByteArray
+
+    constructor(value: string | ByteArray, format: 'hex' | 'bytes' = 'hex') {
+        super()
+
+        let bytes: ByteArray
+        if (format === 'bytes') {
+            bytes = bytesToHexBytes(
+                value instanceof Uint8Array ? value : stringToBytes(value),
+            )
+        } else {
+            bytes = value instanceof Uint8Array ? value : stringToBytes(value)
+        }
+
+        this.raw = bytes
+    }
+
+    static toHexadecimal(data: string | ByteArray): PdfHexadecimal {
+        return new PdfHexadecimal(data, 'bytes')
+    }
+
+    get bytes(): ByteArray {
+        return hexBytesToBytes(this.raw)
+    }
+
+    toHexBytes(): ByteArray {
+        return bytesToHexBytes(this.raw)
+    }
+
+    toHexString(): string {
+        return bytesToString(this.toHexBytes())
+    }
+
+    protected tokenize() {
+        return [new PdfHexadecimalToken(this.raw)]
+    }
+
+    clone(): this {
+        return new PdfHexadecimal(new Uint8Array(this.raw)) as this
+    }
+}