pdf-lite 1.0.0

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

@@ -0,0 +1,38 @@
+import { ByteArray } from '../../types'
+import { bytesToString } from '../../utils/bytesToString'
+import { stringToBytes } from '../../utils/stringToBytes'
+import { PdfStringToken } from '../tokens/string-token'
+import { PdfObject } from './pdf-object'
+
+export class PdfString extends PdfObject {
+    /**
+     * The raw bytes of the PDF string.
+     */
+    private _raw: ByteArray
+
+    constructor(raw: ByteArray | string) {
+        super()
+        this._raw = typeof raw === 'string' ? stringToBytes(raw) : raw
+    }
+
+    get raw(): ByteArray {
+        return this._raw
+    }
+
+    set raw(raw: ByteArray) {
+        this.setModified()
+        this._raw = raw
+    }
+
+    get value(): string {
+        return bytesToString(this.raw)
+    }
+
+    protected tokenize() {
+        return [new PdfStringToken(this.raw)]
+    }
+
+    clone(): this {
+        return new PdfString(new Uint8Array(this.raw)) as this
+    }
+}

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

@@ -0,0 +1,57 @@
+import { Ref } from '../ref'
+import { PdfByteOffsetToken } from '../tokens/byte-offset-token'
+import { PdfToken } from '../tokens/token'
+import { PdfTrailerToken } from '../tokens/trailer-token'
+import { PdfWhitespaceToken } from '../tokens/whitespace-token'
+import { PdfArray } from './pdf-array'
+import { PdfDictionary } from './pdf-dictionary'
+import { PdfHexadecimal } from './pdf-hexadecimal'
+import { PdfNumber } from './pdf-number'
+import { PdfObject } from './pdf-object'
+import { PdfObjectReference } from './pdf-object-reference'
+
+export type PdfTrailerEntries = {
+    Size: PdfNumber
+    Root?: PdfObjectReference
+    Info?: PdfObjectReference
+    Prev?: PdfNumber
+    XRefStm?: PdfNumber
+    Encrypt?: PdfObjectReference
+    ID?: PdfArray<PdfHexadecimal>
+}
+
+export type PdfTrailerDictionary = PdfDictionary<PdfTrailerEntries>
+
+export class PdfTrailer extends PdfObject {
+    dict: PdfTrailerDictionary
+    offset: Ref<number> = new Ref(0)
+
+    constructor(entries: PdfTrailerEntries | PdfDictionary<PdfTrailerEntries>) {
+        super()
+        this.dict =
+            entries instanceof PdfDictionary
+                ? entries
+                : new PdfDictionary(entries)
+    }
+
+    protected tokenize(): PdfToken[] {
+        return [
+            new PdfByteOffsetToken(this.offset),
+            new PdfTrailerToken(),
+            ...(this.dict.preTokens ? [] : [PdfWhitespaceToken.NEWLINE]),
+            ...this.dict.toTokens(),
+        ]
+    }
+
+    clone(): this {
+        return new PdfTrailer(this.dict.clone()) as this
+    }
+
+    isModified(): boolean {
+        return (
+            super.isModified() ||
+            this.dict.isModified() ||
+            this.offset.isModified
+        )
+    }
+}

package/packages/pdf-lite/src/core/objects/pdf-xref-table.ts

@@ -0,0 +1,264 @@
+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 { PdfIndirectObject } from './pdf-indirect-object'
+import { PdfNumber } from './pdf-number'
+import { PdfObject } from './pdf-object'
+
+export 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
+    }) {
+        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
+    }
+
+    protected tokenize() {
+        return [
+            new PdfXRefTableEntryToken(
+                this.byteOffset.toToken(),
+                this.generationNumber.toToken(),
+                this.objectNumber.toToken(),
+                this.inUse,
+            ),
+        ]
+    }
+
+    clone(): this {
+        return new PdfXRefTableEntry({
+            byteOffset: this.byteOffset.clone(),
+            objectNumber: this.objectNumber.clone(),
+            generationNumber: this.generationNumber.clone(),
+            inUse: this.inUse,
+        }) as this
+    }
+
+    isModified(): boolean {
+        return (
+            super.isModified() ||
+            this.byteOffset.isModified() ||
+            this.objectNumber.isModified() ||
+            this.generationNumber.isModified()
+        )
+    }
+}
+
+export class PdfXRefTableSectionHeader extends PdfObject {
+    startObjectNumber: PdfNumber
+    entryCount: PdfNumber
+
+    constructor(options: {
+        startObjectNumber: number | PdfNumber
+        entryCount: number | PdfNumber
+    }) {
+        super()
+        this.startObjectNumber = new PdfNumber(options.startObjectNumber)
+        this.entryCount = new PdfNumber(options.entryCount)
+    }
+
+    protected tokenize() {
+        return [
+            new PdfXRefTableSectionStartToken(
+                this.startObjectNumber.value,
+                this.entryCount.value,
+            ),
+        ]
+    }
+
+    clone(): this {
+        return new PdfXRefTableSectionHeader({
+            startObjectNumber: this.startObjectNumber.clone(),
+            entryCount: this.entryCount.clone(),
+        }) as this
+    }
+}
+
+export class PdfXRefTable extends PdfObject {
+    sections: PdfXRefTableSectionHeader[]
+    entries: PdfXRefTableEntry[]
+    offset: Ref<number> = new Ref(0)
+
+    constructor(options?: {
+        sections?: PdfXRefTableSectionHeader[]
+        entries?: PdfXRefTableEntry[]
+        offset?: Ref<number> | number
+    }) {
+        super()
+        this.sections = options?.sections ?? []
+        this.entries = options?.entries ?? []
+        if (options?.offset) {
+            this.offset.update(options.offset)
+        }
+    }
+
+    isModified(): boolean {
+        return (
+            super.isModified() ||
+            this.sections.some((section) => section.isModified()) ||
+            this.entries.some((entry) => entry.isModified()) ||
+            this.offset.isModified
+        )
+    }
+
+    addEntryForObject(obj: PdfIndirectObject): void {
+        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: number): PdfXRefTableEntry | undefined {
+        return this.entries.find(
+            (entry) => entry.objectNumber.value === objectNumber,
+        )
+    }
+
+    get lastSection(): PdfXRefTableSectionHeader | null {
+        if (this.sections.length === 0) {
+            return null
+        }
+        return this.sections[this.sections.length - 1]
+    }
+
+    protected 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,
+        ]
+    }
+
+    private sortEntriesIntoSections(): {
+        section: PdfXRefTableSectionHeader
+        entries: PdfXRefTableEntry[]
+    }[] {
+        const sections: {
+            section: PdfXRefTableSectionHeader
+            entries: PdfXRefTableEntry[]
+        }[] = []
+
+        let currentSection: PdfXRefTableSectionHeader | null = null
+        let currentEntries: PdfXRefTableEntry[] = []
+
+        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(): this {
+        return new PdfXRefTable({
+            sections: this.sections.map((s) => s.clone()),
+            entries: this.entries.map((e) => e.clone()),
+            offset: new Ref(this.offset.resolve()),
+        }) as this
+    }
+}

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

@@ -0,0 +1,22 @@
+/**
+ * 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 abstract class Parser<I, O> {
+    /**
+     * Feeds input items to the parser.
+     *
+     * @param input - Input items to process
+     */
+    abstract feed(...input: I[]): void
+
+    /**
+     * Generates output items from the fed input.
+     *
+     * @returns A generator yielding output items
+     */
+    abstract nextItems(): Generator<O>
+}

package/packages/pdf-lite/src/core/ref.ts

@@ -0,0 +1,102 @@
+/**
+ * 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 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 = 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>) {
+        if (value === this) {
+            throw new Error('Cannot create Ref to itself')
+        }
+        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>) {
+        if (newValue === this) {
+            return
+        }
+
+        const resolvedNewValue =
+            newValue instanceof Ref ? newValue.resolve() : newValue
+
+        const oldValue = this.resolve()
+        if (oldValue !== resolvedNewValue) {
+            this.isModified = true
+        }
+
+        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 {
+        if (this.value instanceof Ref) {
+            return this.value.resolve()
+        }
+        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 {
+        if (other === undefined) {
+            return false
+        }
+
+        if (other instanceof Ref) {
+            return this.resolve() === other.resolve()
+        }
+
+        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)
+    }
+}

package/packages/pdf-lite/src/core/serializer.ts

@@ -0,0 +1,68 @@
+import { ByteArray } from '../types'
+import { Parser } from './parser'
+import { PdfByteOffsetToken } from './tokens/byte-offset-token'
+import { PdfToken } from './tokens/token'
+
+/**
+ * Serializes PDF tokens into a byte stream.
+ * Handles byte offset calculation and token serialization.
+ */
+export class PdfTokenSerializer extends Parser<PdfToken, number> {
+    /** Current byte offset in the output stream */
+    offset: number = 0
+    private buffer: PdfToken[] = []
+
+    /**
+     * Feeds tokens into the serializer buffer.
+     *
+     * @param input - PDF tokens to serialize
+     */
+    feed(...input: PdfToken[]): void {
+        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> {
+        while (this.buffer.length) {
+            const obj = this.buffer.shift()!
+
+            if (obj instanceof PdfByteOffsetToken) {
+                obj.update(this.offset)
+                continue
+            }
+
+            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
+
+        for (const token of this.buffer) {
+            if (token instanceof PdfByteOffsetToken) {
+                token.update(currentOffset)
+            }
+            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()))
+    }
+}

package/packages/pdf-lite/src/core/streams/object-stream.ts

@@ -0,0 +1,20 @@
+import { PdfObject } from '../objects/pdf-object'
+import { ByteArray } from '../../types'
+import { IterableReadableStream } from '../../utils/IterableReadableStream'
+import { pdfDecoderAsync } from '../generators'
+
+export class PdfObjectStream extends IterableReadableStream<PdfObject> {
+    constructor(input: AsyncIterable<ByteArray> | Iterable<ByteArray>) {
+        super({
+            async start(controller) {
+                const decoder = pdfDecoderAsync(input)
+
+                for await (const obj of decoder) {
+                    controller.enqueue(obj)
+                }
+
+                controller.close()
+            },
+        })
+    }
+}