pdf-lite 1.0.0

package/packages/pdf-lite/src/core/objects/pdf-indirect-object.ts

@@ -0,0 +1,137 @@
+import { PdfEndObjectToken } from '../tokens/end-object-token'
+import { PdfStartObjectToken } from '../tokens/start-object-token'
+import { PdfWhitespaceToken } from '../tokens/whitespace-token'
+import { PdfNull } from './pdf-null'
+import { PdfObject } from './pdf-object'
+import { PdfObjectReference } from './pdf-object-reference'
+import { PdfStream } from './pdf-stream'
+import { Ref } from '../ref'
+import { PdfByteOffsetToken } from '../tokens/byte-offset-token'
+
+export class PdfIndirectObject<
+    T extends PdfObject = PdfObject,
+> extends PdfObjectReference {
+    static readonly MAX_ORDER_INDEX = 2147483647
+
+    content: T
+    offset: Ref<number>
+    encryptable?: boolean
+    orderIndex?: number
+
+    constructor(
+        options:
+            | {
+                  objectNumber?: number
+                  generationNumber?: number
+                  content: T
+                  offset?: number | Ref<number>
+                  encryptable?: boolean
+              }
+            | T,
+    ) {
+        if (options instanceof PdfObject) {
+            super(-1, 0)
+            this.content = options
+            this.offset = new Ref(0)
+            return
+        }
+
+        super(options.objectNumber ?? -1, options.generationNumber ?? 0)
+        this.content = options.content
+        this.offset =
+            options.offset instanceof Ref
+                ? options.offset
+                : new Ref(options.offset ?? 0)
+        this.encryptable = options.encryptable
+    }
+
+    get reference(): PdfObjectReference {
+        return new Proxy(this, {
+            get: (target, prop) => {
+                const value = new PdfObjectReference(
+                    target.objectNumber,
+                    target.generationNumber,
+                )
+                if (prop === 'objectNumber') {
+                    return target.objectNumber
+                } else if (prop === 'generationNumber') {
+                    return target.generationNumber
+                } else {
+                    return value[prop as keyof PdfObjectReference]
+                }
+            },
+        })
+    }
+
+    isEncryptable() {
+        if (this.encryptable === undefined) {
+            if (
+                this.content instanceof PdfStream &&
+                this.content.isType('XRef')
+            ) {
+                return false
+            }
+        }
+
+        return this.encryptable ?? true
+    }
+
+    static createPlaceholder<T extends PdfObject>(
+        objectNumber?: number,
+        generationNumber?: number,
+        content?: T,
+    ): PdfIndirectObject<T extends unknown ? PdfNull : T> {
+        return new PdfIndirectObject({
+            objectNumber: objectNumber ?? -1,
+            generationNumber: generationNumber ?? 0,
+            content: content ?? (new PdfNull() as any),
+            offset: -1,
+        })
+    }
+
+    inPdf() {
+        return this.objectNumber >= 1
+    }
+
+    matchesReference(ref?: PdfObjectReference) {
+        if (!ref) {
+            return false
+        }
+        return (
+            this.objectNumber === ref.objectNumber &&
+            this.generationNumber === ref.generationNumber
+        )
+    }
+
+    protected tokenize() {
+        return [
+            new PdfByteOffsetToken(this.offset),
+            new PdfStartObjectToken(this.objectNumber, this.generationNumber),
+            ...(this.content.preTokens ? [] : [PdfWhitespaceToken.NEWLINE]),
+            ...this.content.toTokens(),
+            ...(this.content.postTokens ? [] : [PdfWhitespaceToken.NEWLINE]),
+            new PdfEndObjectToken(),
+        ]
+    }
+
+    clone(): this {
+        return new PdfIndirectObject({
+            objectNumber: this.objectNumber,
+            generationNumber: this.generationNumber,
+            content: this.content.clone(),
+            offset: this.offset.resolve(),
+        }) as this
+    }
+
+    order(): number {
+        return this.orderIndex ?? 0
+    }
+
+    isModified(): boolean {
+        return (
+            super.isModified() ||
+            this.content.isModified() ||
+            this.offset.isModified
+        )
+    }
+}

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

@@ -0,0 +1,19 @@
+import { PdfNameToken } from '../tokens/name-token'
+import { PdfObject } from './pdf-object'
+
+export class PdfName<T extends string = string> extends PdfObject {
+    value: T
+
+    constructor(value: T) {
+        super()
+        this.value = value
+    }
+
+    protected tokenize() {
+        return [new PdfNameToken(this.value)]
+    }
+
+    clone(): this {
+        return new PdfName(this.value) as this
+    }
+}

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

@@ -0,0 +1,15 @@
+import { PdfObject } from './pdf-object'
+import { PdfNullToken } from '../tokens/null-token'
+import { PdfToken } from '../tokens/token'
+
+export class PdfNull extends PdfObject {
+    static readonly NULL: PdfNull = new PdfNull()
+
+    protected tokenize() {
+        return [new PdfNullToken()]
+    }
+
+    clone(): this {
+        return new PdfNull() as this
+    }
+}

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

@@ -0,0 +1,98 @@
+import { Ref } from '../ref'
+import { PdfNumberToken } from '../tokens/number-token'
+import { PdfObject } from './pdf-object'
+
+export class PdfNumber extends PdfObject {
+    #value: Ref<number>
+    padTo: number
+    decimalPlaces: number
+    isByteOffset: boolean = false
+
+    constructor(
+        options:
+            | {
+                  value: number | Ref<number>
+                  padTo?: number
+                  decimalPlaces?: number
+              }
+            | number
+            | Ref<number>
+            | PdfNumber = 0,
+    ) {
+        super()
+        if (options instanceof Ref) {
+            this.#value = options
+            this.padTo = 0
+            this.decimalPlaces = 0
+        } else if (options instanceof PdfNumber) {
+            this.#value = options.ref
+            this.padTo = options.padTo
+            this.decimalPlaces = options.decimalPlaces
+            this.preTokens = options.preTokens
+            this.postTokens = options.postTokens
+        } else if (typeof options === 'number') {
+            this.#value = new Ref(options)
+            this.padTo = 0
+            this.decimalPlaces = 0
+        } else {
+            this.#value =
+                typeof options.value === 'number'
+                    ? new Ref(options.value)
+                    : options.value
+            this.padTo = options.padTo ?? 0
+            this.decimalPlaces = options.decimalPlaces ?? 0
+        }
+
+        if (
+            this.value === Number.POSITIVE_INFINITY ||
+            this.value === Number.NEGATIVE_INFINITY
+        ) {
+            throw new Error('PDF numbers cannot be infinite')
+        }
+    }
+
+    get ref() {
+        return this.#value
+    }
+
+    get value() {
+        return this.#value.resolve()
+    }
+
+    set value(value: number) {
+        this.#value.update(value)
+    }
+
+    onChange(callback: (value: number) => void): void {
+        this.#value.onUpdate(callback)
+    }
+
+    toToken(): PdfNumberToken {
+        return new PdfNumberToken({
+            value: this.#value,
+            padTo: this.padTo,
+            decimalPlaces: this.decimalPlaces,
+            isByteToken: this.isByteOffset,
+        })
+    }
+
+    protected tokenize() {
+        return [this.toToken()]
+    }
+
+    clone(): this {
+        return new PdfNumber({
+            value: this.value,
+            padTo: this.padTo,
+            decimalPlaces: this.decimalPlaces,
+        }) as this
+    }
+
+    isModified(): boolean {
+        return super.isModified() || this.#value.isModified
+    }
+}
+
+export class PdfByteOffsetNumber extends PdfNumber {
+    isByteOffset: boolean = true
+}

package/packages/pdf-lite/src/core/objects/pdf-object-reference.ts

@@ -0,0 +1,30 @@
+import { PdfToken } from '../tokens/token'
+import { PdfObjectReferenceToken } from '../tokens/object-reference-token'
+import { PdfObject } from './pdf-object'
+
+export class PdfObjectReference extends PdfObject {
+    objectNumber: number
+    generationNumber: number
+
+    constructor(objectNumber: number, generationNumber: number) {
+        super()
+        this.objectNumber = objectNumber
+        this.generationNumber = generationNumber
+    }
+
+    protected tokenize(): PdfToken[] {
+        return [
+            new PdfObjectReferenceToken(
+                this.objectNumber,
+                this.generationNumber,
+            ),
+        ]
+    }
+
+    clone(): this {
+        return new PdfObjectReference(
+            this.objectNumber,
+            this.generationNumber,
+        ) as this
+    }
+}

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

@@ -0,0 +1,107 @@
+import { ByteArray } from '../../types.js'
+import { concatUint8Arrays } from '../../utils/concatUint8Arrays.js'
+import { PdfToken } from '../tokens/token.js'
+import { PdfWhitespaceToken } from '../tokens/whitespace-token.js'
+
+export abstract class PdfObject {
+    /** Optional tokens to prepend or append during serialization */
+    preTokens?: PdfToken[]
+    /** Optional tokens to prepend or append during serialization */
+    postTokens?: PdfToken[]
+    /** Indicates whether the object has been modified. By default, assume it has been modified because it's a new object */
+    protected modified: boolean = true
+    /** Tokenizes the object into an array of PdfTokens */
+    protected abstract tokenize(): PdfToken[]
+
+    /** The type of this PDF object */
+    get objectType(): string {
+        return this.constructor.name
+    }
+
+    /** Indicates whether the object has been modified. Override this method if the modified state is determined differently */
+    isModified(): boolean {
+        return this.modified
+    }
+
+    /** Sets the modified state of the object. Override this method if the modified state is determined differently */
+    setModified(modified: boolean = true): void {
+        this.modified = modified
+    }
+
+    /** Converts the object to an array of PdfTokens, including any pre or post tokens */
+    toTokens(): PdfToken[] {
+        return [
+            ...(this.preTokens ?? []),
+            ...this.tokenize(),
+            ...(this.postTokens ?? []),
+        ]
+    }
+
+    /** Converts the object to a ByteArray, optionally padding to a specified length */
+    toBytes(padTo?: number): ByteArray {
+        const tokens = this.toTokens()
+
+        const byteArray = concatUint8Arrays(
+            ...tokens.map((token) => token.toBytes()),
+        )
+        if (padTo) {
+            const paddedArray = new Uint8Array(padTo)
+            paddedArray.set(byteArray)
+            return paddedArray
+        }
+        return byteArray
+    }
+
+    /** Converts the object to a string representation */
+    toString(): string {
+        let str = ''
+        for (const byte of this.toBytes()) {
+            str += String.fromCharCode(byte)
+        }
+        return str
+    }
+
+    /** Attempts to cast the object to a specific PdfObject subclass */
+    as<T extends PdfObject>(ctor: new (...args: any[]) => T): T {
+        if (this instanceof ctor) {
+            return this as T
+        }
+
+        throw new Error(
+            `Cannot cast object of type ${this.objectType} to ${ctor.name}`,
+        )
+    }
+
+    /** Creates a deep clone of the object */
+    abstract clone(): this
+
+    /** Compares this object to another for equality based on their token representations */
+    equals(other?: PdfObject): boolean {
+        if (!other) {
+            return false
+        }
+
+        const tokensA = this.toTokens().filter(
+            (x) => !(x instanceof PdfWhitespaceToken),
+        )
+
+        const tokensB = other
+            .toTokens()
+            .filter((x) => !(x instanceof PdfWhitespaceToken))
+
+        if (tokensA.length !== tokensB.length) {
+            return false
+        }
+
+        for (let i = 0; i < tokensA.length; i++) {
+            const tokenA = tokensA[i]
+            const tokenB = tokensB[i]
+
+            if (!tokenA.equals(tokenB)) {
+                return false
+            }
+        }
+
+        return true
+    }
+}

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

@@ -0,0 +1,39 @@
+import { Ref } from '../ref'
+import { PdfStartXRefToken } from '../tokens/start-xref-token'
+import { PdfWhitespaceToken } from '../tokens/whitespace-token'
+import { PdfNumber } from './pdf-number'
+import { PdfObject } from './pdf-object'
+
+export class PdfStartXRef extends PdfObject {
+    offset: PdfNumber
+
+    constructor(offset: number | PdfNumber | Ref<number> = -1) {
+        // default to -1 for unknown offset
+        super()
+        this.offset =
+            offset instanceof PdfNumber
+                ? offset
+                : new PdfNumber({ value: offset })
+        this.offset.isByteOffset = true
+    }
+
+    protected tokenize() {
+        const whiteSpaceTokens = this.offset.preTokens
+            ? []
+            : [PdfWhitespaceToken.NEWLINE]
+
+        return [
+            new PdfStartXRefToken(),
+            ...whiteSpaceTokens,
+            ...this.offset.toTokens(),
+        ]
+    }
+
+    clone(): this {
+        return new PdfStartXRef(this.offset.clone()) as this
+    }
+
+    isModified(): boolean {
+        return super.isModified() || this.offset.isModified()
+    }
+}