pdf-lite 1.0.0

package/packages/pdf-lite/src/core/tokens/byte-offset-token.ts

@@ -0,0 +1,20 @@
+import { Ref } from '../ref'
+import { PdfToken } from './token'
+
+export class PdfByteOffsetToken extends PdfToken {
+    value: Ref<number>
+
+    constructor(value: Ref<number> = new Ref(0)) {
+        super(new Uint8Array())
+
+        this.value = value
+    }
+
+    resolve(): number {
+        return this.value.resolve()
+    }
+
+    update(offset: number | Ref<number>): void {
+        this.value.update(offset)
+    }
+}

package/packages/pdf-lite/src/core/tokens/comment-token.ts

@@ -0,0 +1,32 @@
+import { stringToBytes } from '../../utils/stringToBytes'
+import { concatUint8Arrays } from '../../utils/concatUint8Arrays'
+import { PdfToken } from './token'
+import { ByteArray } from '../../types'
+import { bytesToString } from '../../utils/bytesToString'
+
+export class PdfCommentToken extends PdfToken {
+    static EOF = new PdfCommentToken('%EOF')
+    comment: ByteArray
+
+    constructor(comment: ByteArray | string) {
+        super(PdfCommentToken.toBytes(comment))
+        this.comment =
+            typeof comment === 'string' ? stringToBytes(comment) : comment
+    }
+
+    get innerComment(): string {
+        return bytesToString(this.comment)
+    }
+
+    private static toBytes(comment: ByteArray | string): ByteArray {
+        const tokenBytes =
+            typeof comment === 'string' ? stringToBytes(comment) : comment
+        return concatUint8Arrays(stringToBytes('%'), tokenBytes)
+    }
+
+    static isEofCommentToken(token: PdfToken): boolean {
+        if (!(token instanceof PdfCommentToken)) return false
+        const tokenStr = token.innerComment.trim()
+        return tokenStr.toLowerCase() === '%eof'
+    }
+}

package/packages/pdf-lite/src/core/tokens/end-array-token.ts

@@ -0,0 +1,10 @@
+import { stringToBytes } from '../../utils/stringToBytes'
+import { PdfToken } from './token'
+
+const END_ARRAY_BYTES = stringToBytes(']')
+
+export class PdfEndArrayToken extends PdfToken {
+    constructor() {
+        super(END_ARRAY_BYTES)
+    }
+}

package/packages/pdf-lite/src/core/tokens/end-dictionary-token.ts

@@ -0,0 +1,10 @@
+import { stringToBytes } from '../../utils/stringToBytes'
+import { PdfToken } from './token'
+
+const END_DICTIONARY_BYTES = stringToBytes('>>')
+
+export class PdfEndDictionaryToken extends PdfToken {
+    constructor() {
+        super(END_DICTIONARY_BYTES)
+    }
+}

package/packages/pdf-lite/src/core/tokens/end-object-token.ts

@@ -0,0 +1,10 @@
+import { stringToBytes } from '../../utils/stringToBytes'
+import { PdfToken } from './token'
+
+const END_OBJECT_BYTES = stringToBytes('endobj')
+
+export class PdfEndObjectToken extends PdfToken {
+    constructor() {
+        super(END_OBJECT_BYTES)
+    }
+}

package/packages/pdf-lite/src/core/tokens/end-stream-token.ts

@@ -0,0 +1,11 @@
+import { ByteArray } from '../../types'
+import { stringToBytes } from '../../utils/stringToBytes'
+import { PdfToken } from './token'
+
+const END_STREAM_BYTES = stringToBytes('endstream')
+
+export class PdfEndStreamToken extends PdfToken {
+    constructor(bytes?: ByteArray) {
+        super(bytes ?? END_STREAM_BYTES)
+    }
+}

package/packages/pdf-lite/src/core/tokens/hexadecimal-token.ts

@@ -0,0 +1,22 @@
+import { ByteArray } from '../../types'
+import { stringToBytes } from '../../utils/stringToBytes'
+import { PdfToken } from './token'
+
+export class PdfHexadecimalToken extends PdfToken {
+    raw: ByteArray
+
+    constructor(hexadecimal: string | ByteArray) {
+        super(PdfHexadecimalToken.toBytes(hexadecimal))
+
+        this.raw =
+            typeof hexadecimal === 'string'
+                ? stringToBytes(hexadecimal)
+                : hexadecimal
+    }
+
+    private static toBytes(hexadecimal: string | ByteArray): ByteArray {
+        const bytes = stringToBytes(hexadecimal)
+
+        return new Uint8Array([0x3c, ...bytes, 0x3e])
+    }
+}

package/packages/pdf-lite/src/core/tokens/name-token.ts

@@ -0,0 +1,19 @@
+import { ByteArray } from '../../types'
+import { stringToBytes } from '../../utils/stringToBytes'
+import { PdfToken } from './token'
+
+export class PdfNameToken extends PdfToken {
+    name: string
+
+    constructor(name: string) {
+        if (typeof name !== 'string' || name.length === 0) {
+            throw new Error('PdfNameToken name must be a non-empty string')
+        }
+        super(PdfNameToken.toBytes(name))
+        this.name = name
+    }
+
+    private static toBytes(name: string): ByteArray {
+        return stringToBytes(`/${name}`)
+    }
+}

package/packages/pdf-lite/src/core/tokens/null-token.ts

@@ -0,0 +1,9 @@
+import { stringToBytes } from '../../utils/stringToBytes'
+import { PdfToken } from './token'
+
+const NULL = stringToBytes('null')
+export class PdfNullToken extends PdfToken {
+    constructor() {
+        super(NULL)
+    }
+}

package/packages/pdf-lite/src/core/tokens/number-token.ts

@@ -0,0 +1,164 @@
+import { ByteArray } from '../../types'
+import { stringToBytes } from '../../utils/stringToBytes'
+import { Ref } from '../ref'
+import { PdfToken } from './token'
+
+export class PdfNumberToken extends PdfToken {
+    #value: Ref<number>
+    padTo: number
+    decimalPlaces: number
+    isByteToken: boolean = false
+
+    constructor(
+        options:
+            | {
+                  value: number | ByteArray | PdfNumberToken | Ref<number>
+                  padTo?: number
+                  decimalPlaces?: number
+                  isByteToken?: boolean
+              }
+            | number
+            | ByteArray,
+        padTo?: number,
+        decimalPlaces?: number,
+    ) {
+        super()
+
+        if (
+            typeof options === 'number' ||
+            options instanceof Uint8Array ||
+            options instanceof Ref ||
+            options instanceof PdfNumberToken
+        ) {
+            this.#value = PdfNumberToken.getValue(options)
+            this.padTo = padTo ?? 0
+            this.decimalPlaces = decimalPlaces ?? 0
+            this.isByteToken = false
+            return
+        }
+
+        this.#value = PdfNumberToken.getValue(options.value)
+        this.padTo = options.padTo ?? 0
+
+        this.decimalPlaces =
+            options.decimalPlaces ??
+            PdfNumberToken.getDecimalPlaces(options.value)
+        this.isByteToken = options.isByteToken ?? false
+    }
+
+    toBytes(): ByteArray {
+        return PdfNumberToken.toBytes(
+            this.#value,
+            this.padTo,
+            this.decimalPlaces,
+        )
+    }
+
+    get ref(): Ref<number> {
+        return this.#value
+    }
+
+    set ref(newRef: Ref<number>) {
+        this.#value = newRef
+    }
+
+    get value(): number {
+        return this.#value.resolve()
+    }
+
+    set value(newValue: number) {
+        this.#value.update(newValue)
+    }
+
+    static getValue(
+        bytes: ByteArray | PdfNumberToken | number | Ref<number>,
+    ): Ref<number> {
+        if (bytes instanceof Ref) {
+            return bytes
+        }
+
+        if (bytes instanceof PdfNumberToken) {
+            return bytes.ref
+        }
+
+        if (typeof bytes === 'number') {
+            return new Ref(bytes)
+        }
+
+        const str = new TextDecoder().decode(bytes)
+        return new Ref(parseFloat(str))
+    }
+
+    static getPadding(
+        bytes: ByteArray | PdfNumberToken | number | Ref<number>,
+    ): number {
+        if (bytes instanceof PdfNumberToken) {
+            return bytes.padTo
+        }
+
+        if (bytes instanceof Ref) {
+            bytes = PdfNumberToken.toBytes(bytes.resolve())
+        }
+
+        if (typeof bytes === 'number') {
+            bytes = PdfNumberToken.toBytes(bytes)
+        }
+
+        let padding = 0
+        while (bytes.length && bytes[0] === 0x30) {
+            bytes = bytes.slice(1)
+            padding++
+        }
+
+        return padding
+    }
+
+    static getDecimalPlaces(
+        bytes: ByteArray | PdfNumberToken | number | Ref<number>,
+    ): number {
+        if (bytes instanceof PdfNumberToken) {
+            return bytes.decimalPlaces
+        }
+
+        if (bytes instanceof Ref) {
+            bytes = PdfNumberToken.toBytes(bytes.resolve())
+        }
+
+        if (typeof bytes === 'number') {
+            bytes = PdfNumberToken.toBytes(bytes)
+        }
+
+        const str = new TextDecoder().decode(bytes)
+        const match = str.match(/\.(\d+)/)
+
+        if (match) {
+            return match[1].length
+        }
+
+        return 0
+    }
+
+    static toBytes(
+        value: number | PdfNumberToken | Ref<number> | ByteArray,
+        padTo?: number,
+        decimalPlaces?: number,
+    ): ByteArray {
+        if (value instanceof Uint8Array) {
+            return value
+        }
+
+        if (value instanceof PdfNumberToken) {
+            return value.toBytes()
+        }
+
+        const numberValue = value instanceof Ref ? value.resolve() : value
+
+        const valueString = decimalPlaces
+            ? numberValue.toFixed(decimalPlaces)
+            : numberValue.toString()
+
+        const tokenString = valueString.padStart(padTo ?? 0, '0')
+
+        return stringToBytes(tokenString)
+    }
+}

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

@@ -0,0 +1,24 @@
+import { ByteArray } from '../../types'
+import { stringToBytes } from '../../utils/stringToBytes'
+import { PdfToken } from './token'
+
+export class PdfObjectReferenceToken extends PdfToken {
+    objectNumber: number
+    generationNumber: number
+
+    constructor(objectNumber: number, generationNumber: number) {
+        super(PdfObjectReferenceToken.toBytes(objectNumber, generationNumber))
+        this.objectNumber = objectNumber
+        this.generationNumber = generationNumber
+    }
+
+    private static toBytes(
+        objectNumber: number,
+        generationNumber: number,
+    ): ByteArray {
+        const objNumStr = objectNumber.toString()
+        const genNumStr = generationNumber.toString()
+        const refStr = `${objNumStr} ${genNumStr} R`
+        return stringToBytes(refStr)
+    }
+}

package/packages/pdf-lite/src/core/tokens/start-array-token.ts

@@ -0,0 +1,10 @@
+import { stringToBytes } from '../../utils/stringToBytes'
+import { PdfToken } from './token'
+
+const START_ARRAY_BYTES = stringToBytes('[')
+
+export class PdfStartArrayToken extends PdfToken {
+    constructor() {
+        super(START_ARRAY_BYTES)
+    }
+}

package/packages/pdf-lite/src/core/tokens/start-dictionary-token.ts

@@ -0,0 +1,10 @@
+import { stringToBytes } from '../../utils/stringToBytes'
+import { PdfToken } from './token'
+
+const START_DICTIONARY_BYTES = stringToBytes('<<')
+
+export class PdfStartDictionaryToken extends PdfToken {
+    constructor() {
+        super(START_DICTIONARY_BYTES)
+    }
+}

package/packages/pdf-lite/src/core/tokens/start-object-token.ts

@@ -0,0 +1,28 @@
+import { ByteArray } from '../../types'
+import { stringToBytes } from '../../utils/stringToBytes'
+import { PdfToken } from './token'
+
+export class PdfStartObjectToken extends PdfToken {
+    objectNumber: number
+    generationNumber: number
+    byteOffset?: number
+
+    constructor(
+        objectNumber: number,
+        generationNumber: number,
+        byteOffset?: number,
+    ) {
+        super(PdfStartObjectToken.toBytes(objectNumber, generationNumber))
+        this.objectNumber = objectNumber
+        this.generationNumber = generationNumber
+        this.byteOffset = byteOffset
+    }
+
+    private static toBytes(
+        objectNumber: number,
+        generationNumber: number,
+    ): ByteArray {
+        const tokenString = `${objectNumber} ${generationNumber} obj`
+        return stringToBytes(tokenString)
+    }
+}

package/packages/pdf-lite/src/core/tokens/start-stream-token.ts

@@ -0,0 +1,52 @@
+import { ByteArray } from '../../types'
+import { stringToBytes } from '../../utils/stringToBytes'
+import { PdfToken } from './token'
+import { PdfWhitespaceToken } from './whitespace-token'
+
+const START_STREAM_WITHOUT_WHITESPACE_BYTES = stringToBytes('stream')
+const START_STREAM_BYTES = stringToBytes('stream\n')
+
+export class PdfStartStreamToken extends PdfToken {
+    constructor(bytes?: ByteArray) {
+        super(bytes ?? START_STREAM_BYTES)
+    }
+
+    getTrailingWhitespaceTokens(): PdfWhitespaceToken[] {
+        const tokens: PdfWhitespaceToken[] = []
+        const bytes = this.toBytes()
+
+        for (let i = bytes.length - 1; i >= 0; i--) {
+            const byte = bytes[i]
+            if (!PdfWhitespaceToken.isWhitespaceByte(byte)) {
+                continue
+            }
+
+            tokens.push(new PdfWhitespaceToken(byte))
+        }
+        return tokens.reverse()
+    }
+
+    static withTrailingWhitespace(
+        whitespaceTokens: PdfToken[] | undefined,
+    ): PdfStartStreamToken {
+        if (!whitespaceTokens || whitespaceTokens.length === 0) {
+            return new PdfStartStreamToken()
+        }
+
+        const totalLength =
+            START_STREAM_WITHOUT_WHITESPACE_BYTES.length +
+            whitespaceTokens.reduce((sum, token) => sum + token.byteLength, 0)
+
+        const bytes = new Uint8Array(totalLength)
+        bytes.set(START_STREAM_WITHOUT_WHITESPACE_BYTES, 0)
+
+        let offset = START_STREAM_WITHOUT_WHITESPACE_BYTES.length
+        for (const token of whitespaceTokens) {
+            const tokenBytes = token.toBytes()
+            bytes.set(tokenBytes, offset)
+            offset += tokenBytes.length
+        }
+
+        return new PdfStartStreamToken(bytes)
+    }
+}

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

@@ -0,0 +1,10 @@
+import { stringToBytes } from '../../utils/stringToBytes'
+import { PdfToken } from './token'
+
+const START_XREF = stringToBytes('startxref')
+
+export class PdfStartXRefToken extends PdfToken {
+    constructor() {
+        super(START_XREF)
+    }
+}

package/packages/pdf-lite/src/core/tokens/stream-chunk-token.ts

@@ -0,0 +1,8 @@
+import { ByteArray } from '../../types'
+import { PdfToken } from './token'
+
+export class PdfStreamChunkToken extends PdfToken {
+    constructor(bytes: ByteArray) {
+        super(bytes)
+    }
+}

package/packages/pdf-lite/src/core/tokens/string-token.ts

@@ -0,0 +1,17 @@
+import { ByteArray } from '../../types'
+import { escapeString } from '../../utils/escapeString'
+import { stringToBytes } from '../../utils/stringToBytes'
+import { PdfToken } from './token'
+
+export class PdfStringToken extends PdfToken {
+    value: ByteArray
+
+    constructor(value: string | ByteArray) {
+        super(PdfStringToken.toBytes(value))
+        this.value = typeof value === 'string' ? stringToBytes(value) : value
+    }
+
+    private static toBytes(value: string | ByteArray): ByteArray {
+        return new Uint8Array([0x28, ...escapeString(value), 0x29])
+    }
+}

package/packages/pdf-lite/src/core/tokens/token.ts

@@ -0,0 +1,43 @@
+import { ByteArray } from '../../types'
+import { bytesToString } from '../../utils/bytesToString'
+
+export abstract class PdfToken {
+    protected rawBytes: ByteArray
+
+    constructor(bytes?: ByteArray) {
+        this.rawBytes = bytes ?? new Uint8Array()
+    }
+
+    toBytes(): ByteArray {
+        return this.rawBytes
+    }
+
+    toString(): string {
+        return bytesToString(this.toBytes())
+    }
+
+    get type(): string {
+        return this.constructor.name
+    }
+
+    get byteLength(): number {
+        return this.toBytes().length
+    }
+
+    equals(other: PdfToken): boolean {
+        if (this.byteLength !== other.byteLength) {
+            return false
+        }
+
+        const bytes = this.toBytes()
+        const otherBytes = other.toBytes()
+
+        for (let i = 0; i < this.byteLength; i++) {
+            if (bytes[i] !== otherBytes[i]) {
+                return false
+            }
+        }
+
+        return true
+    }
+}

package/packages/pdf-lite/src/core/tokens/trailer-token.ts

@@ -0,0 +1,12 @@
+import { stringToBytes } from '../../utils/stringToBytes'
+import { PdfToken } from './token'
+
+const TRAILER = stringToBytes('trailer')
+
+export class PdfTrailerToken extends PdfToken {
+    byteOffset?: number
+    constructor(byteOffset?: number) {
+        super(TRAILER)
+        this.byteOffset = byteOffset
+    }
+}

package/packages/pdf-lite/src/core/tokens/whitespace-token.ts

@@ -0,0 +1,43 @@
+import { ByteArray } from '../../types'
+import { PdfToken } from './token'
+
+export class PdfWhitespaceToken extends PdfToken {
+    public static NEWLINE = new PdfWhitespaceToken('\n')
+    public static SPACE = new PdfWhitespaceToken(' ')
+    public static TAB = new PdfWhitespaceToken('\t')
+    public static CARRIAGE_RETURN = new PdfWhitespaceToken('\r')
+
+    constructor(value: string | ByteArray | number) {
+        super(PdfWhitespaceToken.toBytes(value))
+    }
+
+    private static toBytes(value: string | ByteArray | number): ByteArray {
+        if (value instanceof Uint8Array) {
+            return value
+        }
+
+        if (typeof value === 'number') {
+            return new Uint8Array([value])
+        }
+
+        switch (value) {
+            case ' ':
+                return new Uint8Array([0x20]) // space character
+            case '\t':
+                return new Uint8Array([0x09]) // tab character
+            case '\n':
+                return new Uint8Array([0x0a]) // newline character
+            case '\r':
+                return new Uint8Array([0x0d]) // carriage return character
+            default:
+                throw new Error(`Invalid whitespace character: ${value}`)
+        }
+    }
+
+    static isWhitespaceByte(byte: number | null | undefined): boolean {
+        if (byte === null || byte === undefined) {
+            return false
+        }
+        return byte === 0x20 || byte === 0x0a || byte === 0x0d || byte === 0x09
+    }
+}

package/packages/pdf-lite/src/core/tokens/xref-table-entry-token.ts

@@ -0,0 +1,65 @@
+import { ByteArray } from '../../types'
+import { stringToBytes } from '../../utils/stringToBytes'
+import { Ref } from '../ref'
+import { PdfNumberToken } from './number-token'
+import { PdfToken } from './token.js'
+
+export class PdfXRefTableEntryToken extends PdfToken {
+    objectNumber: PdfNumberToken
+    generationNumber: PdfNumberToken
+    offset: PdfNumberToken
+    inUse: boolean
+
+    constructor(
+        offset: number | Ref<number> | PdfNumberToken,
+        generationNumber: number | PdfNumberToken,
+        objectNumber: number | PdfNumberToken,
+        inUse: boolean,
+    ) {
+        super()
+        this.objectNumber =
+            objectNumber instanceof PdfNumberToken
+                ? objectNumber
+                : new PdfNumberToken({ value: objectNumber })
+        this.generationNumber =
+            generationNumber instanceof PdfNumberToken
+                ? generationNumber
+                : new PdfNumberToken({ value: generationNumber })
+        this.offset =
+            offset instanceof PdfNumberToken
+                ? offset
+                : new PdfNumberToken({ value: offset })
+        this.inUse = inUse
+    }
+
+    toBytes(): ByteArray {
+        return PdfXRefTableEntryToken.toBytes(
+            this.generationNumber,
+            this.offset,
+            this.inUse,
+        )
+    }
+
+    private static toBytes(
+        generationNumber: number | PdfNumberToken,
+        offset: number | PdfNumberToken | Ref<number>,
+        inUse: boolean,
+    ): ByteArray {
+        const offsetString =
+            offset instanceof PdfNumberToken
+                ? offset.toString()
+                : new PdfNumberToken({ value: offset, padTo: 10 }).toString()
+
+        const generationNumberString =
+            generationNumber instanceof PdfNumberToken
+                ? generationNumber.toString()
+                : new PdfNumberToken({
+                      value: generationNumber,
+                      padTo: 5,
+                  }).toString()
+
+        return stringToBytes(
+            `${offsetString} ${generationNumberString} ${inUse ? 'n' : 'f'}`,
+        )
+    }
+}