pdf-lite 1.0.0

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

@@ -0,0 +1,687 @@
+import { PdfToken } from '../tokens/token'
+import { PdfEndStreamToken } from '../tokens/end-stream-token'
+import { PdfStartStreamToken } from '../tokens/start-stream-token'
+import { PdfStreamChunkToken } from '../tokens/stream-chunk-token'
+import { PdfWhitespaceToken } from '../tokens/whitespace-token'
+import { PdfDictionary } from './pdf-dictionary'
+import { PdfObject } from './pdf-object'
+import { PdfName } from './pdf-name'
+import { PdfArray } from './pdf-array'
+import { flate } from '../../filters/flate'
+import { asciiHex } from '../../filters/asciihex'
+import { ascii85 } from '../../filters/ascii85'
+import { lzw } from '../../filters/lzw'
+import { runLength } from '../../filters/runlength'
+import { passthroughFilter } from '../../filters/pass-through'
+import { ByteArray } from '../../types'
+import { PdfNumber } from './pdf-number'
+import { Predictor } from '../../utils/predictors'
+import { bytesToPdfObjects } from '../generators'
+import { PdfIndirectObject } from './pdf-indirect-object'
+import { PdfXRefTableEntry } from './pdf-xref-table'
+import { stringToBytes } from '../../utils/stringToBytes'
+import { PdfFilter, PdfStreamFilterType } from '../../filters/types'
+
+export class PdfStream<
+    T extends PdfDictionary = PdfDictionary,
+> extends PdfObject {
+    header: T
+    original: ByteArray
+    preStreamDataTokens?: PdfToken[]
+    postStreamDataTokens?: PdfToken[]
+
+    constructor(
+        options:
+            | { header: T; original: ByteArray | string; isModified?: boolean }
+            | ByteArray
+            | string,
+    ) {
+        super()
+
+        if (typeof options === 'string' || options instanceof Uint8Array) {
+            options = { header: new PdfDictionary() as T, original: options }
+        }
+
+        this.header = options.header
+        this.modified = options.isModified ?? true
+        this.original =
+            typeof options.original === 'string'
+                ? stringToBytes(options.original)
+                : options.original
+        if (!this.header.get('Length')) {
+            this.header.set('Length', new PdfNumber(this.original.length))
+        }
+    }
+
+    get raw(): ByteArray {
+        const length = this.header.get('Length')?.as(PdfNumber)?.value
+        if (length === undefined) return this.original
+
+        return this.original.slice(0, length)
+    }
+
+    set raw(data: ByteArray) {
+        this.setModified()
+        this.original = data
+        this.header.set('Length', new PdfNumber(data.length))
+    }
+
+    get originalAsString(): string {
+        return new TextDecoder().decode(this.original)
+    }
+
+    get rawAsString(): string {
+        return new TextDecoder().decode(this.raw)
+    }
+
+    getFilters(): PdfStreamFilterType[] {
+        const filters = this.header.get('Filter') as
+            | PdfArray<PdfName<PdfStreamFilterType>>
+            | PdfName<PdfStreamFilterType>
+            | undefined
+        if (!filters) {
+            return []
+        }
+
+        if (filters instanceof PdfName) {
+            return [filters.value]
+        } else if (filters instanceof PdfArray) {
+            return filters.items.map((item) => item.value)
+        } else {
+            throw new Error('Invalid Filter entry in PDF stream')
+        }
+    }
+
+    addFilter(filterName: PdfStreamFilterType) {
+        const filters = this.header.get('Filter')
+
+        if (!filters) {
+            this.header.set('Filter', new PdfName(filterName))
+        } else if (filters instanceof PdfName) {
+            this.header.set(
+                'Filter',
+                new PdfArray([new PdfName(filterName), filters]),
+            )
+        } else if (filters instanceof PdfArray) {
+            filters.items.unshift(new PdfName(filterName))
+        } else {
+            throw new Error('Invalid Filter entry in PDF stream')
+        }
+
+        const filter = PdfStream.getFilter(filterName)
+        this.raw = filter.encode(this.raw)
+        return this
+    }
+
+    setPredictor(predictorParams: {
+        Predictor?: number
+        Columns?: number
+        Colors?: number
+        BitsPerComponent?: number
+    }) {
+        let decodeParms = this.header.get('DecodeParms')?.as(PdfDictionary)
+
+        if (!decodeParms) {
+            decodeParms = new PdfDictionary()
+            this.header.set('DecodeParms', decodeParms)
+        } else if (decodeParms instanceof PdfDictionary) {
+            // already a dictionary
+        } else {
+            throw new Error('Invalid DecodeParms entry in PDF stream')
+        }
+
+        for (const [key, value] of Object.entries(predictorParams)) {
+            decodeParms.set(key, new PdfNumber(value))
+        }
+
+        this.raw = Predictor.encode(this.raw, predictorParams)
+
+        return this
+    }
+
+    removeFilter(filterName: PdfStreamFilterType) {
+        let filters = this.header.get('Filter')
+        if (!filters) {
+            return this
+        }
+
+        const decoded = this.decode()
+
+        if (filters instanceof PdfName) {
+            if (filters.value === filterName) {
+                this.header.delete('Filter')
+            }
+        } else if (filters instanceof PdfArray) {
+            filters.items = filters.items.filter(
+                (item) => item.value !== filterName,
+            )
+            if (filters.items.length === 0) {
+                this.header.delete('Filter')
+            } else if (filters.items.length === 1) {
+                this.header.set('Filter', filters.items[0])
+            }
+        } else {
+            throw new Error('Invalid Filter entry in PDF stream')
+        }
+
+        const finalFilters = this.getFilters()
+        const encoded = PdfStream.applyFilters(decoded, finalFilters)
+        this.raw = encoded
+        return this
+    }
+
+    removePredictor() {
+        const decoded = this.decode()
+        this.header.delete('DecodeParms')
+        this.raw = decoded
+        return this
+    }
+
+    removeAllFilters() {
+        const decoded = this.decode()
+        this.raw = decoded
+        this.header.delete('Filter')
+        return this
+    }
+
+    decode(): ByteArray {
+        let data: ByteArray = this.raw
+        const filters = this.getFilters()
+
+        for (const filterName of filters) {
+            const filter = PdfStream.getFilter(filterName)
+            data = filter.decode(data)
+        }
+
+        const predictorParams = Predictor.getDecodeParms(
+            this.header.get('DecodeParms')?.as(PdfDictionary),
+        )
+
+        if (predictorParams) {
+            data = Predictor.decode(data, predictorParams)
+        }
+
+        return data
+    }
+
+    parseAs<T extends PdfStream>(
+        Class: new (options: {
+            header: PdfDictionary
+            original: ByteArray
+            isModified?: boolean
+        }) => T,
+    ): T {
+        const instance = new Class({
+            header: this.header,
+            original: this.original,
+            isModified: this.isModified(),
+        })
+        instance.preTokens = this.preTokens
+        instance.postTokens = this.postTokens
+        instance.preStreamDataTokens = this.preStreamDataTokens
+        instance.postStreamDataTokens = this.postStreamDataTokens
+
+        return instance
+    }
+
+    protected tokenize() {
+        return [
+            ...this.header.toTokens(),
+            PdfStartStreamToken.withTrailingWhitespace(
+                this.preStreamDataTokens,
+            ),
+            new PdfStreamChunkToken(this.original),
+            new PdfEndStreamToken(),
+        ]
+    }
+
+    isType(name: string): boolean {
+        const type = this.header.get('Type')
+        return type instanceof PdfName && type.value === name
+    }
+
+    static getFilter(name: PdfStreamFilterType): PdfFilter {
+        const allFilters = PdfStream.getAllFilters()
+        if (!allFilters[name]) {
+            throw new Error(`Unsupported filter: ${name}`)
+        }
+
+        return allFilters[name]
+    }
+
+    static getAllFilters() {
+        return {
+            FlateDecode: flate(),
+            Fl: flate(),
+            ASCIIHexDecode: asciiHex(),
+            ASCII85Decode: ascii85(),
+            LZWDecode: lzw(),
+            RunLengthDecode: runLength(),
+            CCITTFaxDecode: passthroughFilter(),
+            DCTDecode: passthroughFilter(),
+            JPXDecode: passthroughFilter(),
+            Crypt: passthroughFilter(),
+        } as const satisfies {
+            [key in PdfStreamFilterType]: PdfFilter
+        }
+    }
+
+    static applyFilters(
+        data: ByteArray,
+        filters: PdfStreamFilterType[],
+    ): ByteArray {
+        let result = data
+        for (const filterName of filters) {
+            const filter = PdfStream.getFilter(filterName)
+            if (!filter) {
+                throw new Error(`Unsupported filter: ${filterName}`)
+            }
+            result = filter.encode(result)
+        }
+        return result
+    }
+
+    clone(): this {
+        return new PdfStream({
+            header: this.header.clone(),
+            original: new Uint8Array(this.original),
+        }) as this
+    }
+}
+
+export class PdfObjStream extends PdfStream {
+    constructor(options: {
+        header: PdfDictionary
+        original: ByteArray | string
+        isModified?: boolean
+    }) {
+        super(options)
+
+        if (!this.isType('ObjStm')) {
+            throw new Error('PDF Object Stream must be of type ObjStm')
+        }
+    }
+
+    static fromObjects(objects: Iterable<PdfIndirectObject>): PdfObjStream {
+        let header = ''
+        let objectData = ''
+
+        let offset = 0
+
+        for (const obj of objects) {
+            header += `${obj.objectNumber} ${offset} `
+            const objString = obj.content.toString()
+            objectData += objString + '\n'
+            offset += objString.length + 1
+        }
+
+        const headerDict = new PdfDictionary()
+        headerDict.set('Type', new PdfName('ObjStm'))
+        headerDict.set('N', new PdfNumber(header.length))
+        headerDict.set('First', new PdfNumber(offset))
+
+        objectData = `${header.trim()}\n${objectData.trim()}`
+
+        return new PdfObjStream({
+            header: headerDict,
+            original: objectData,
+        })
+    }
+
+    *getObjectStream(): Generator<PdfIndirectObject> {
+        const decodedData = this.decode()
+        const reader = bytesToPdfObjects([decodedData])
+        const numbers: PdfNumber[] = []
+        let i = 0
+
+        while (true) {
+            const { value: obj, done } = reader.next()
+            if (done) break
+
+            if (obj instanceof PdfDictionary) {
+                const objectNumber = numbers[i * 2].value
+                const generationNumber = 0
+
+                yield new PdfIndirectObject({
+                    objectNumber,
+                    generationNumber,
+                    content: obj,
+                })
+
+                i++
+            } else if (obj instanceof PdfNumber) {
+                numbers.push(obj)
+            } else {
+                throw new Error('Invalid object in PDF Object Stream')
+            }
+        }
+    }
+
+    getObject(options: {
+        objectNumber: number
+    }): PdfIndirectObject | undefined {
+        for (const obj of this.getObjectStream()) {
+            if (obj.objectNumber === options.objectNumber) {
+                return obj
+            }
+        }
+        return undefined
+    }
+
+    getObjects(): PdfIndirectObject[] {
+        return Array.from(this.getObjectStream())
+    }
+
+    clone(): this {
+        return new PdfObjStream({
+            header: this.header.clone(),
+            original: new Uint8Array(this.original),
+        }) as this
+    }
+}
+
+export class PdfXRefStreamCompressedEntry {
+    objectNumber: PdfNumber
+    objectStreamNumber: PdfNumber
+    index: PdfNumber
+
+    constructor(options: {
+        objectNumber: number | PdfNumber
+        objectStreamNumber: number | PdfNumber
+        index: number | PdfNumber
+    }) {
+        this.objectNumber =
+            options.objectNumber instanceof PdfNumber
+                ? options.objectNumber
+                : new PdfNumber(options.objectNumber)
+        this.objectStreamNumber =
+            options.objectStreamNumber instanceof PdfNumber
+                ? options.objectStreamNumber
+                : new PdfNumber(options.objectStreamNumber)
+        this.index =
+            options.index instanceof PdfNumber
+                ? options.index
+                : new PdfNumber(options.index)
+    }
+}
+
+export type PdfXRefStreamStandardEntry = PdfXRefTableEntry
+export const PdfXRefStreamStandardEntry = PdfXRefTableEntry
+
+export type PdfXRefStreamEntry =
+    | PdfXRefStreamStandardEntry
+    | PdfXRefStreamCompressedEntry
+
+export class PdfXRefStream extends PdfStream {
+    constructor(options?: {
+        header?: PdfDictionary
+        original?: ByteArray | string
+        isModified?: boolean
+    }) {
+        super({
+            header: options?.header ?? PdfXRefStream.createNewHeader(),
+            original: options?.original ?? new Uint8Array(),
+            isModified: options?.isModified,
+        })
+
+        if (!this.isType('XRef')) {
+            throw new Error('PDF XRef Stream must be of type XRef')
+        }
+    }
+
+    static createNewHeader(): PdfDictionary {
+        const headerDict = new PdfDictionary()
+        headerDict.set('Type', new PdfName('XRef'))
+        headerDict.set(
+            'W',
+            new PdfArray([
+                new PdfNumber(1),
+                new PdfNumber(4),
+                new PdfNumber(2),
+            ]),
+        )
+        headerDict.set('Size', new PdfNumber(0))
+
+        return headerDict
+    }
+
+    static fromEntries(
+        entries: PdfXRefStreamEntry[],
+        headerDict: PdfDictionary = new PdfDictionary(),
+    ): PdfXRefStream {
+        headerDict.delete('DecodeParms')
+        headerDict.delete('Filter')
+        headerDict.set('Type', new PdfName('XRef'))
+        entries.sort((a, b) => a.objectNumber.value - b.objectNumber.value)
+
+        const W = this.calculateW(entries)
+        headerDict.set('W', new PdfArray(W.map((w) => new PdfNumber(w))))
+
+        // Build Index array - pairs of [start, count] for each contiguous range
+        const indexArray: number[] = []
+        if (entries.length > 0) {
+            let rangeStart = entries[0].objectNumber.value
+            let rangeCount = 1
+
+            for (let i = 1; i < entries.length; i++) {
+                const currentNum = entries[i].objectNumber.value
+                const prevNum = entries[i - 1].objectNumber.value
+
+                if (currentNum === prevNum + 1) {
+                    // Contiguous - extend current range
+                    rangeCount++
+                } else {
+                    // Gap found - save current range and start new one
+                    indexArray.push(rangeStart, rangeCount)
+                    rangeStart = currentNum
+                    rangeCount = 1
+                }
+            }
+
+            // Add final range
+            indexArray.push(rangeStart, rangeCount)
+        }
+
+        headerDict.set(
+            'Index',
+            new PdfArray(indexArray.map((num) => new PdfNumber(num))),
+        )
+
+        const size =
+            entries.length === 0
+                ? 0
+                : Math.max(
+                      ...entries.map((entry) => entry.objectNumber.value),
+                  ) + 1
+        headerDict.set('Size', new PdfNumber(size))
+
+        // Encode entries to bytes
+        const entrySize = W.reduce((a, b) => a + b, 0)
+        const streamBytes = new Uint8Array(entries.length * entrySize)
+        let offset = 0
+
+        for (const entry of entries) {
+            const typeByte =
+                entry instanceof PdfXRefTableEntry ? (entry.inUse ? 1 : 0) : 2
+
+            let field1 = typeByte
+            let field2 = 0
+            let field3 = 0
+
+            if (entry instanceof PdfXRefTableEntry) {
+                field2 = entry.byteOffset.value
+                field3 = entry.generationNumber.value
+            } else if (entry instanceof PdfXRefStreamCompressedEntry) {
+                field2 = entry.objectStreamNumber.value
+                field3 = entry.index.value
+            }
+
+            for (let i = 0; i < W[0]; i++) {
+                streamBytes[offset++] = (field1 >> (8 * (W[0] - 1 - i))) & 0xff
+            }
+            for (let i = 0; i < W[1]; i++) {
+                streamBytes[offset++] = (field2 >> (8 * (W[1] - 1 - i))) & 0xff
+            }
+            for (let i = 0; i < W[2]; i++) {
+                streamBytes[offset++] = (field3 >> (8 * (W[2] - 1 - i))) & 0xff
+            }
+        }
+
+        const rawData = new Uint8Array(streamBytes)
+        headerDict.set('Length', new PdfNumber(rawData.length))
+
+        return new PdfXRefStream({
+            header: headerDict,
+            original: rawData,
+        })
+    }
+
+    addEntry(entry: PdfXRefStreamEntry) {
+        const entries = this.getEntries()
+        entries.push(entry)
+
+        const newXRefStream = PdfXRefStream.fromEntries(entries)
+
+        this.header = newXRefStream.header
+        this.raw = newXRefStream.raw
+
+        return this
+    }
+
+    private static calculateW(entries: PdfXRefStreamEntry[]): number[] {
+        let maxGeneration = 0
+
+        const maxOffset = Math.max(
+            ...entries.map((entry) => {
+                let value = 0
+
+                if (entry instanceof PdfXRefTableEntry) {
+                    value = entry.byteOffset.value
+                    maxGeneration = Math.max(
+                        maxGeneration,
+                        entry.generationNumber.value,
+                    )
+                } else if (entry instanceof PdfXRefStreamCompressedEntry) {
+                    value = entry.objectStreamNumber.value
+                }
+
+                return value
+            }),
+        )
+
+        const W1 = 1 // Type byte
+        const W2 =
+            maxOffset === -1 ? 0 : Math.ceil(Math.log2(maxOffset + 1) / 8) || 1 // Offset or next free
+        const W3 = Math.ceil(Math.log2(maxGeneration + 1) / 8) || 1 // Generation number or index
+
+        return [W1, W2, W3]
+    }
+
+    get prev(): PdfNumber | undefined {
+        const prev = this.header.get('Prev')
+        return prev instanceof PdfNumber ? prev : undefined
+    }
+
+    *getEntryStream(): Generator<PdfXRefStreamEntry> {
+        const data = this.decode()
+
+        const header = this.header
+        const W = header
+            .get('W')
+            ?.as(PdfArray<PdfNumber>)
+            ?.items?.map((v: any) => v.value)
+
+        if (!W) throw new Error('Missing W entry in XRef stream')
+
+        if (W.length !== 3) {
+            throw new Error(
+                'Invalid W entry in XRef stream. Expected array of 3 numbers.',
+            )
+        }
+
+        const entrySize = W[0] + W[1] + W[2]
+
+        const Index = header
+            .get('Index')
+            ?.as(PdfArray<PdfNumber>)
+            ?.items?.map((v) => v.value)
+
+        const Size = header.get('Size')!.as(PdfNumber).value
+
+        const objectRanges: [number, number][] = Index
+            ? Array.from({ length: Index.length / 2 }, (_, i) => [
+                  Index[i * 2],
+                  Index[i * 2 + 1],
+              ])
+            : [[0, Size]]
+
+        const expectedLength =
+            objectRanges.reduce((sum, [, count]) => sum + count, 0) * entrySize
+        if (data.length < expectedLength) {
+            throw new Error(
+                `XRef stream too short: expected ${expectedLength} bytes, got ${data.length}`,
+            )
+        }
+
+        let offset = 0
+
+        for (const [startObj, count] of objectRanges) {
+            for (let i = 0; i < count; i++) {
+                const objectNumber = startObj + i
+
+                const type = this.readInt(data, offset, W[0])
+                offset += W[0]
+                const field2 = this.readInt(data, offset, W[1])
+                offset += W[1]
+                const field3 = this.readInt(data, offset, W[2])
+                offset += W[2]
+
+                let entry: PdfXRefStreamEntry
+                if (type === 0) {
+                    entry = new PdfXRefTableEntry({
+                        objectNumber,
+                        generationNumber: field3,
+                        byteOffset: field2,
+                        inUse: false,
+                    })
+                } else if (type === 1) {
+                    entry = new PdfXRefTableEntry({
+                        objectNumber,
+                        generationNumber: field3,
+                        byteOffset: field2,
+                        inUse: true,
+                    })
+                } else if (type === 2) {
+                    entry = new PdfXRefStreamCompressedEntry({
+                        objectNumber,
+                        objectStreamNumber: field2,
+                        index: field3,
+                    })
+                } else {
+                    throw new Error(`Unknown xref entry type: ${type}`)
+                }
+
+                yield entry
+            }
+        }
+    }
+
+    getEntries(): PdfXRefStreamEntry[] {
+        return Array.from(this.getEntryStream())
+    }
+
+    private readInt(data: ByteArray, offset: number, length: number): number {
+        let value = 0
+        for (let i = 0; i < length; i++) {
+            value = (value << 8) | data[offset + i]
+        }
+        return value
+    }
+
+    clone(): this {
+        return new PdfXRefStream({
+            header: this.header.clone(),
+            original: new Uint8Array(this.original),
+        }) as this
+    }
+}