pdf-lite 1.0.0

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

@@ -0,0 +1,144 @@
+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/filters/pass-through.ts

@@ -0,0 +1,37 @@
+import { ByteArray } from '../types.js'
+import { PdfFilter } from './types.js'
+
+/**
+ * Creates a pass-through filter that performs no transformation.
+ * Returns data unchanged, useful for testing or as a placeholder filter.
+ *
+ * @returns A PdfFilter object with encode and decode methods that return data unchanged.
+ *
+ * @example
+ * ```typescript
+ * const filter = passthroughFilter()
+ * const result = filter.encode(data) // Returns data unchanged
+ * ```
+ */
+export function passthroughFilter(): PdfFilter {
+    return {
+        /**
+         * Returns the data unchanged.
+         *
+         * @param data - The data to pass through.
+         * @returns The same data unchanged.
+         */
+        decode: (data: ByteArray) => {
+            return data
+        },
+        /**
+         * Returns the data unchanged.
+         *
+         * @param data - The data to pass through.
+         * @returns The same data unchanged.
+         */
+        encode: (data: ByteArray) => {
+            return data
+        },
+    }
+}

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

@@ -0,0 +1,92 @@
+import { ByteArray } from '../types.js'
+import { PdfFilter } from './types.js'
+
+/**
+ * Creates a Run-Length filter for encoding and decoding PDF stream data.
+ * Run-Length encoding is a simple compression algorithm that replaces
+ * sequences of repeated bytes with a count and the byte value.
+ *
+ * @returns A PdfFilter object with encode and decode methods.
+ *
+ * @example
+ * ```typescript
+ * const filter = runLength()
+ * const compressed = filter.encode(rawData)
+ * const decompressed = filter.decode(compressed)
+ * ```
+ */
+export function runLength(): PdfFilter {
+    return {
+        /**
+         * Compresses data using Run-Length encoding.
+         * Appends 128 as the end-of-data marker.
+         *
+         * @param data - The data to compress.
+         * @returns The Run-Length encoded data as a byte array.
+         */
+        encode: (data: ByteArray) => {
+            const out: number[] = []
+            let i = 0
+            while (i < data.length) {
+                let runLength = 1
+                while (
+                    runLength < 128 &&
+                    i + runLength < data.length &&
+                    data[i] === data[i + runLength]
+                ) {
+                    runLength++
+                }
+                if (runLength > 1) {
+                    out.push(257 - runLength)
+                    out.push(data[i])
+                    i += runLength
+                } else {
+                    let literalLength = 1
+                    while (
+                        literalLength < 128 &&
+                        i + literalLength < data.length &&
+                        (data[i + literalLength] !==
+                            data[i + literalLength - 1] ||
+                            literalLength === 1)
+                    ) {
+                        literalLength++
+                    }
+                    out.push(literalLength - 1)
+                    for (let j = 0; j < literalLength; ++j) {
+                        out.push(data[i + j])
+                    }
+                    i += literalLength
+                }
+            }
+            out.push(128) // EOD
+            return new Uint8Array(out)
+        },
+        /**
+         * Decompresses Run-Length encoded data.
+         * Stops at the end-of-data marker (128).
+         *
+         * @param data - The Run-Length encoded data to decompress.
+         * @returns The decompressed data as a byte array.
+         */
+        decode: (data: ByteArray) => {
+            const out: number[] = []
+            let i = 0
+            while (i < data.length) {
+                const len = data[i++]
+                if (len === 128) break // EOD
+                if (len < 128) {
+                    for (let j = 0; j < len + 1; ++j) {
+                        out.push(data[i++])
+                    }
+                } else if (len > 128) {
+                    const count = 257 - len
+                    const value = data[i++]
+                    for (let j = 0; j < count; ++j) {
+                        out.push(value)
+                    }
+                }
+            }
+            return new Uint8Array(out)
+        },
+    }
+}

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

@@ -0,0 +1,21 @@
+import { ByteArray } from '../types'
+
+export interface PdfFilter {
+    encode(data: ByteArray): ByteArray
+    decode(data: ByteArray): ByteArray
+}
+
+export const PDF_FILTER_TYPES = {
+    FlateDecode: 'FlateDecode',
+    Fl: 'Fl',
+    ASCIIHexDecode: 'ASCIIHexDecode',
+    ASCII85Decode: 'ASCII85Decode',
+    LZWDecode: 'LZWDecode',
+    RunLengthDecode: 'RunLengthDecode',
+    CCITTFaxDecode: 'CCITTFaxDecode',
+    DCTDecode: 'DCTDecode',
+    JPXDecode: 'JPXDecode',
+    Crypt: 'Crypt',
+} as const
+
+export type PdfStreamFilterType = keyof typeof PDF_FILTER_TYPES

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

@@ -0,0 +1,4 @@
+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/errors.ts

@@ -0,0 +1,5 @@
+/**
+ * Error thrown when attempting to access a compressed object
+ * that requires decompression from an object stream.
+ */
+export class FoundCompressedObjectError extends Error {}

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

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