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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

@@ -1,65 +0,0 @@
-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'}`,
-        )
-    }
-}