pdf-lite 1.0.1-alpha.2 → 1.0.1

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

@@ -1,31 +0,0 @@
-import { ByteArray } from '../../types'
-import { stringToBytes } from '../../utils/stringToBytes'
-import { PdfNumberToken } from './number-token'
-import { PdfToken } from './token'
-
-export class PdfXRefTableSectionStartToken extends PdfToken {
-    start: PdfNumberToken
-    count: PdfNumberToken
-
-    constructor(
-        start: number | PdfNumberToken,
-        count: number | PdfNumberToken,
-    ) {
-        super(PdfXRefTableSectionStartToken.toBytes(start, count))
-        this.start =
-            start instanceof PdfNumberToken
-                ? start
-                : new PdfNumberToken({ value: start })
-        this.count =
-            count instanceof PdfNumberToken
-                ? count
-                : new PdfNumberToken({ value: count })
-    }
-
-    private static toBytes(
-        start: PdfNumberToken | number,
-        count: PdfNumberToken | number,
-    ): ByteArray {
-        return stringToBytes(`${start.toString()} ${count.toString()}`)
-    }
-}

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

@@ -1,13 +0,0 @@
-import { stringToBytes } from '../../utils/stringToBytes'
-import { PdfToken } from './token'
-
-const XREF = stringToBytes('xref')
-
-export class PdfXRefTableStartToken extends PdfToken {
-    byteOffset?: number
-
-    constructor(byteOffset?: number) {
-        super(XREF)
-        this.byteOffset = byteOffset
-    }
-}

package/packages/pdf-lite/src/crypto/key-derivation/key-derivation-aes256.ts

@@ -1,213 +0,0 @@
-import { ByteArray } from '../../types'
-import {
-    aes128CbcNoPaddingEncrypt,
-    aes256CbcNoPaddingDecrypt,
-    sha256,
-    sha384,
-    sha512,
-} from '../../utils/algos'
-import { assert } from '../../utils/assert'
-
-/**
- * Converts the first 16 bytes of input to a big-endian bigint.
- *
- * @param input - The byte array to convert.
- * @returns A 128-bit bigint value.
- */
-function getUint16ByteBigEndian(input: ByteArray): bigint {
-    let value = 0n
-    for (let i = 0; i < 16; i++) {
-        value = (value << 8n) | BigInt(input[i])
-    }
-    return value
-}
-
-/**
- * Computes the Algorithm 2.B hash for PDF 2.0 AES-256 encryption.
- * This iterative hash algorithm uses SHA-256, SHA-384, or SHA-512 based on
- * intermediate results, running for at least 64 rounds.
- *
- * @param password - The user or owner password.
- * @param salt - The 8-byte validation or key salt.
- * @param userKey - The user key (required for owner password validation). Defaults to empty.
- * @returns A promise that resolves to a 32-byte hash.
- *
- * @example
- * ```typescript
- * const hash = await computeAlgorithm2bHash(password, salt)
- * ```
- */
-export async function computeAlgorithm2bHash(
-    password: ByteArray,
-    salt: ByteArray,
-    userKey: ByteArray = new Uint8Array(),
-): Promise<ByteArray> {
-    // Step 1: Initial hash
-    let K = new Uint8Array(password.length + salt.length + userKey.length)
-    K.set(password)
-    K.set(salt, password.length)
-    K.set(userKey, password.length + salt.length)
-
-    K = await sha256(K)
-
-    let roundNumber = 0
-    let E: ByteArray = new Uint8Array()
-    while (roundNumber < 64 || E.at(-1)! > roundNumber - 32) {
-        // Step 2: K1 = 64 × (password || K || [userKey])
-        const base = new Uint8Array(password.length + K.length + userKey.length)
-        base.set(password)
-        base.set(K, password.length)
-        base.set(userKey, password.length + K.length)
-
-        const K1 = new Uint8Array(base.length * 64)
-        for (let i = 0; i < 64; i++) {
-            K1.set(base, i * base.length)
-        }
-
-        // Step 3: Encrypt K1 with AES-128-CBC using key/iv from K
-        const key = K.subarray(0, 16)
-        const iv = K.subarray(16, 32)
-        E = await aes128CbcNoPaddingEncrypt(key, K1, iv)
-
-        // Step 4: Choose hash
-        const value = getUint16ByteBigEndian(E)
-        const mod = Number(value % 3n)
-
-        if (mod === 0) {
-            K = await sha256(E)
-        } else if (mod === 1) {
-            K = await sha384(E)
-        } else if (mod === 2) {
-            K = await sha512(E)
-        } else {
-            throw new Error('Invalid mod')
-        }
-
-        roundNumber++
-    }
-
-    return K.subarray(0, 32)
-}
-
-/**
- * Validates a password against a stored hash using the Algorithm 2.B hash.
- *
- * @param password - The password to validate.
- * @param key - The stored key containing the hash (first 32 bytes) and validation salt (bytes 32-40).
- * @param extra - Extra data for owner password validation (user key).
- * @returns A promise that resolves to the computed hash if validation succeeds.
- * @throws Error if the password is invalid or salt/hash lengths are incorrect.
- *
- * @example
- * ```typescript
- * try {
- *   await validatePasswordHash(password, storedKey)
- *   console.log('Password is valid')
- * } catch (e) {
- *   console.log('Invalid password')
- * }
- * ```
- */
-export async function validatePasswordHash(
-    password: ByteArray,
-    key: ByteArray,
-    extra?: ByteArray,
-): Promise<ByteArray> {
-    const validationSalt = key.slice(32, 40)
-    if (validationSalt.length !== 8) {
-        throw new Error('Invalid salt length')
-    }
-
-    const hash = await computeAlgorithm2bHash(password, validationSalt, extra)
-
-    if (hash.length !== 32) {
-        throw new Error('Invalid hash length')
-    }
-
-    for (let i = 0; i < 32; i++) {
-        if (hash[i] !== key[i]) {
-            throw new Error('Key mismatch')
-        }
-    }
-
-    return hash
-}
-
-/**
- * Retrieves the file encryption key using user or owner password.
- * Tries owner password first, then falls back to user password.
- *
- * @param userPassword - The user password to try.
- * @param ownerPassword - The owner password to try.
- * @param u - The 48-byte /U value from the encryption dictionary.
- * @param ue - The 32-byte /UE value (encrypted user key).
- * @param o - The 48-byte /O value from the encryption dictionary.
- * @param oe - The 32-byte /OE value (encrypted owner key).
- * @returns A promise that resolves to the 32-byte file encryption key.
- * @throws Error if both passwords are invalid.
- *
- * @example
- * ```typescript
- * const fileKey = await getFileKey(userPw, ownerPw, U, UE, O, OE)
- * ```
- */
-export async function getFileKey(
-    userPassword: ByteArray,
-    ownerPassword: ByteArray,
-    u: ByteArray,
-    ue: ByteArray,
-    o: ByteArray,
-    oe: ByteArray,
-): Promise<ByteArray> {
-    if (userPassword.length > 128) {
-        userPassword = userPassword.subarray(0, 128)
-    }
-
-    if (ownerPassword.length > 128) {
-        ownerPassword = ownerPassword.subarray(0, 128)
-    }
-
-    assert(oe.length === 32, 'Invalid OE length')
-    assert(ue.length === 32, 'Invalid UE length')
-    assert(u.length === 48, 'Invalid U length')
-    assert(o.length === 48, 'Invalid O length')
-
-    try {
-        // First try owner password
-        await validatePasswordHash(ownerPassword, o, u)
-
-        const hash = await computeAlgorithm2bHash(
-            ownerPassword,
-            o.subarray(40, 48),
-            u,
-        )
-
-        const key = await aes256CbcNoPaddingDecrypt(
-            hash,
-            oe,
-            new Uint8Array(16),
-        )
-
-        return key
-    } catch (e) {
-        try {
-            // Then try user password
-
-            await validatePasswordHash(userPassword, u)
-
-            const hash = await computeAlgorithm2bHash(
-                userPassword,
-                u.subarray(40, 48),
-            )
-            const key = await aes256CbcNoPaddingDecrypt(
-                hash,
-                ue,
-                new Uint8Array(16),
-            )
-
-            return key
-        } catch (e) {
-            throw new Error('Invalid password')
-        }
-    }
-}

package/packages/pdf-lite/src/crypto/types.ts

@@ -1,6 +0,0 @@
-import { ByteArray } from '../types'
-
-export interface Cipher {
-    encrypt(data: ByteArray): Promise<ByteArray>
-    decrypt(data: ByteArray): Promise<ByteArray>
-}

package/packages/pdf-lite/src/filters/lzw.ts

@@ -1,144 +0,0 @@
-import { ByteArray } from '../types'
-import { PdfFilter } from './types'
-
-/**
- * Creates an LZW filter for encoding and decoding PDF stream data.
- * LZW (Lempel-Ziv-Welch) is a lossless compression algorithm.
- * This is a minimal implementation for PDF (12-bit, no early change, no predictor).
- *
- * @returns A PdfFilter object with encode and decode methods.
- *
- * @example
- * ```typescript
- * const filter = lzw()
- * const compressed = filter.encode(rawData)
- * const decompressed = filter.decode(compressed)
- * ```
- */
-export function lzw(): PdfFilter {
-    return {
-        /**
-         * Compresses data using the LZW algorithm.
-         *
-         * @param data - The data to compress.
-         * @returns The LZW compressed data as a byte array.
-         */
-        encode: (data: ByteArray) => {
-            // Minimal LZW encode for PDF (12-bit, no early change, no predictor)
-            const CLEAR = 256,
-                EOD = 257
-            let dict = new Map<string, number>()
-            for (let i = 0; i < 256; i++) dict.set(String.fromCharCode(i), i)
-            let codeSize = 9
-            let nextCode = 258
-            let out: number[] = [CLEAR]
-            let w = ''
-            for (let i = 0; i < data.length; i++) {
-                const c = String.fromCharCode(data[i])
-                const wc = w + c
-                if (dict.has(wc)) {
-                    w = wc
-                } else {
-                    out.push(dict.get(w)!)
-                    if (nextCode < 4096) {
-                        dict.set(wc, nextCode++)
-                        if (nextCode === 1 << codeSize && codeSize < 12)
-                            codeSize++
-                    }
-                    w = c
-                }
-            }
-            if (w) out.push(dict.get(w)!)
-            out.push(EOD)
-            // Bit packing
-            let bits = 0,
-                bitBuffer = 0
-            let result: number[] = []
-            codeSize = 9
-            nextCode = 258
-            for (let i = 0; i < out.length; i++) {
-                let code = out[i]
-                bitBuffer |= code << bits
-                bits += codeSize
-                while (bits >= 8) {
-                    result.push(bitBuffer & 0xff)
-                    bitBuffer >>= 8
-                    bits -= 8
-                }
-                if (code === CLEAR) {
-                    codeSize = 9
-                    nextCode = 258
-                } else {
-                    if (nextCode < 4096) {
-                        nextCode++
-                        if (nextCode === 1 << codeSize && codeSize < 12)
-                            codeSize++
-                    }
-                }
-            }
-            if (bits > 0) result.push(bitBuffer & 0xff)
-            return new Uint8Array(result)
-        },
-        /**
-         * Decompresses LZW compressed data.
-         *
-         * @param data - The LZW compressed data to decompress.
-         * @returns The decompressed data as a byte array.
-         */
-        decode: (data: ByteArray) => {
-            // Simple LZW decode for PDF (12-bit, no early change)
-            // Adapted from public domain sources for educational use
-            let pos = 0
-            let bits = 0
-            let bitBuffer = 0
-            function readBits(n: number) {
-                while (bits < n) {
-                    if (pos >= data.length) return null
-                    bitBuffer |= data[pos++] << bits
-                    bits += 8
-                }
-                const out = bitBuffer & ((1 << n) - 1)
-                bitBuffer >>= n
-                bits -= n
-                return out
-            }
-            const CLEAR = 256,
-                EOD = 257
-            let codeSize = 9
-            let dict: ByteArray[] = []
-            for (let i = 0; i < 256; i++) dict[i] = new Uint8Array([i])
-            dict[CLEAR] = undefined as any
-            dict[EOD] = undefined as any
-            let out: number[] = []
-            let prev: ByteArray | undefined
-            let code: number | null
-            while ((code = readBits(codeSize)) !== null) {
-                if (code === CLEAR) {
-                    dict = []
-                    for (let i = 0; i < 256; i++) dict[i] = new Uint8Array([i])
-                    dict[CLEAR] = undefined as any
-                    dict[EOD] = undefined as any
-                    codeSize = 9
-                    prev = undefined
-                    continue
-                }
-                if (code === EOD) break
-                let entry: ByteArray
-                if (dict[code]) {
-                    entry = dict[code]
-                } else if (prev) {
-                    entry = new Uint8Array([...prev, prev[0]])
-                } else {
-                    continue
-                }
-                out.push(...entry)
-                if (prev) {
-                    dict.push(new Uint8Array([...prev, entry[0]]))
-                }
-                prev = entry
-                if (dict.length === 1 << codeSize && codeSize < 12) codeSize++
-            }
-            return new Uint8Array(out)
-        },
-    }
-}

package/packages/pdf-lite/src/index.ts

@@ -1,4 +0,0 @@
-export * from './types.js'
-export * from './pdf/index.js'
-export * from './core/index.js'
-export * from './signing/index.js'

package/packages/pdf-lite/src/pdf/index.ts

@@ -1,4 +0,0 @@
-export * from './pdf-document'
-export * from './pdf-reader'
-export * from './pdf-revision'
-export * from './pdf-xref-lookup'