pdf-lite 1.0.1-alpha.2 → 1.0.1-alpha.3

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

@@ -1,171 +0,0 @@
-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

@@ -1,54 +0,0 @@
-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
-    }
-}

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

@@ -1,137 +0,0 @@
-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

@@ -1,19 +0,0 @@
-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

@@ -1,15 +0,0 @@
-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

@@ -1,98 +0,0 @@
-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

@@ -1,30 +0,0 @@
-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

@@ -1,107 +0,0 @@
-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

@@ -1,39 +0,0 @@
-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()
-    }
-}