pdf-lite 1.0.1-alpha.2 → 1.0.1

package/dist/core/objects/pdf-stream.d.ts

@@ -0,0 +1,100 @@
+import { PdfToken } from '../tokens/token';
+import { PdfDictionary } from './pdf-dictionary';
+import { PdfObject } from './pdf-object';
+import { ByteArray } from '../../types';
+import { PdfNumber } from './pdf-number';
+import { PdfIndirectObject } from './pdf-indirect-object';
+import { PdfXRefTableEntry } from './pdf-xref-table';
+import { PdfFilter, PdfStreamFilterType } from '../../filters/types';
+export declare 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);
+    get raw(): ByteArray;
+    set raw(data: ByteArray);
+    get originalAsString(): string;
+    get rawAsString(): string;
+    getFilters(): PdfStreamFilterType[];
+    addFilter(filterName: PdfStreamFilterType): this;
+    setPredictor(predictorParams: {
+        Predictor?: number;
+        Columns?: number;
+        Colors?: number;
+        BitsPerComponent?: number;
+    }): this;
+    removeFilter(filterName: PdfStreamFilterType): this;
+    removePredictor(): this;
+    removeAllFilters(): this;
+    decode(): ByteArray;
+    parseAs<T extends PdfStream>(Class: new (options: {
+        header: PdfDictionary;
+        original: ByteArray;
+        isModified?: boolean;
+    }) => T): T;
+    protected tokenize(): PdfToken[];
+    isType(name: string): boolean;
+    static getFilter(name: PdfStreamFilterType): PdfFilter;
+    static getAllFilters(): {
+        readonly FlateDecode: PdfFilter;
+        readonly Fl: PdfFilter;
+        readonly ASCIIHexDecode: PdfFilter;
+        readonly ASCII85Decode: PdfFilter;
+        readonly LZWDecode: PdfFilter;
+        readonly RunLengthDecode: PdfFilter;
+        readonly CCITTFaxDecode: PdfFilter;
+        readonly DCTDecode: PdfFilter;
+        readonly JPXDecode: PdfFilter;
+        readonly Crypt: PdfFilter;
+    };
+    static applyFilters(data: ByteArray, filters: PdfStreamFilterType[]): ByteArray;
+    clone(): this;
+}
+export declare class PdfObjStream extends PdfStream {
+    constructor(options: {
+        header: PdfDictionary;
+        original: ByteArray | string;
+        isModified?: boolean;
+    });
+    static fromObjects(objects: Iterable<PdfIndirectObject>): PdfObjStream;
+    getObjectStream(): Generator<PdfIndirectObject>;
+    getObject(options: {
+        objectNumber: number;
+    }): PdfIndirectObject | undefined;
+    getObjects(): PdfIndirectObject[];
+    clone(): this;
+}
+export declare class PdfXRefStreamCompressedEntry {
+    objectNumber: PdfNumber;
+    objectStreamNumber: PdfNumber;
+    index: PdfNumber;
+    constructor(options: {
+        objectNumber: number | PdfNumber;
+        objectStreamNumber: number | PdfNumber;
+        index: number | PdfNumber;
+    });
+}
+export type PdfXRefStreamStandardEntry = PdfXRefTableEntry;
+export declare const PdfXRefStreamStandardEntry: typeof PdfXRefTableEntry;
+export type PdfXRefStreamEntry = PdfXRefStreamStandardEntry | PdfXRefStreamCompressedEntry;
+export declare class PdfXRefStream extends PdfStream {
+    constructor(options?: {
+        header?: PdfDictionary;
+        original?: ByteArray | string;
+        isModified?: boolean;
+    });
+    static createNewHeader(): PdfDictionary;
+    static fromEntries(entries: PdfXRefStreamEntry[], headerDict?: PdfDictionary): PdfXRefStream;
+    addEntry(entry: PdfXRefStreamEntry): this;
+    private static calculateW;
+    get prev(): PdfNumber | undefined;
+    getEntryStream(): Generator<PdfXRefStreamEntry>;
+    getEntries(): PdfXRefStreamEntry[];
+    private readInt;
+    clone(): this;
+}

package/dist/core/objects/pdf-stream.js

@@ -0,0 +1,521 @@
+import { PdfEndStreamToken } from '../tokens/end-stream-token';
+import { PdfStartStreamToken } from '../tokens/start-stream-token';
+import { PdfStreamChunkToken } from '../tokens/stream-chunk-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 { 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';
+export class PdfStream extends PdfObject {
+    header;
+    original;
+    preStreamDataTokens;
+    postStreamDataTokens;
+    constructor(options) {
+        super();
+        if (typeof options === 'string' || options instanceof Uint8Array) {
+            options = { header: new PdfDictionary(), 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() {
+        const length = this.header.get('Length')?.as(PdfNumber)?.value;
+        if (length === undefined)
+            return this.original;
+        return this.original.slice(0, length);
+    }
+    set raw(data) {
+        this.setModified();
+        this.original = data;
+        this.header.set('Length', new PdfNumber(data.length));
+    }
+    get originalAsString() {
+        return new TextDecoder().decode(this.original);
+    }
+    get rawAsString() {
+        return new TextDecoder().decode(this.raw);
+    }
+    getFilters() {
+        const filters = this.header.get('Filter');
+        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) {
+        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) {
+        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) {
+        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() {
+        let data = 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(Class) {
+        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;
+    }
+    tokenize() {
+        return [
+            ...this.header.toTokens(),
+            PdfStartStreamToken.withTrailingWhitespace(this.preStreamDataTokens),
+            new PdfStreamChunkToken(this.original),
+            new PdfEndStreamToken(),
+        ];
+    }
+    isType(name) {
+        const type = this.header.get('Type');
+        return type instanceof PdfName && type.value === name;
+    }
+    static getFilter(name) {
+        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(),
+        };
+    }
+    static applyFilters(data, filters) {
+        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() {
+        return new PdfStream({
+            header: this.header.clone(),
+            original: new Uint8Array(this.original),
+        });
+    }
+}
+export class PdfObjStream extends PdfStream {
+    constructor(options) {
+        super(options);
+        if (!this.isType('ObjStm')) {
+            throw new Error('PDF Object Stream must be of type ObjStm');
+        }
+    }
+    static fromObjects(objects) {
+        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() {
+        const decodedData = this.decode();
+        const reader = bytesToPdfObjects([decodedData]);
+        const numbers = [];
+        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) {
+        for (const obj of this.getObjectStream()) {
+            if (obj.objectNumber === options.objectNumber) {
+                return obj;
+            }
+        }
+        return undefined;
+    }
+    getObjects() {
+        return Array.from(this.getObjectStream());
+    }
+    clone() {
+        return new PdfObjStream({
+            header: this.header.clone(),
+            original: new Uint8Array(this.original),
+        });
+    }
+}
+export class PdfXRefStreamCompressedEntry {
+    objectNumber;
+    objectStreamNumber;
+    index;
+    constructor(options) {
+        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 const PdfXRefStreamStandardEntry = PdfXRefTableEntry;
+export class PdfXRefStream extends PdfStream {
+    constructor(options) {
+        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() {
+        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, headerDict = new PdfDictionary()) {
+        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 = [];
+        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) {
+        const entries = this.getEntries();
+        entries.push(entry);
+        const newXRefStream = PdfXRefStream.fromEntries(entries);
+        this.header = newXRefStream.header;
+        this.raw = newXRefStream.raw;
+        return this;
+    }
+    static calculateW(entries) {
+        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() {
+        const prev = this.header.get('Prev');
+        return prev instanceof PdfNumber ? prev : undefined;
+    }
+    *getEntryStream() {
+        const data = this.decode();
+        const header = this.header;
+        const W = header
+            .get('W')
+            ?.as((PdfArray))
+            ?.items?.map((v) => 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))
+            ?.items?.map((v) => v.value);
+        const Size = header.get('Size').as(PdfNumber).value;
+        const objectRanges = 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;
+                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() {
+        return Array.from(this.getEntryStream());
+    }
+    readInt(data, offset, length) {
+        let value = 0;
+        for (let i = 0; i < length; i++) {
+            value = (value << 8) | data[offset + i];
+        }
+        return value;
+    }
+    clone() {
+        return new PdfXRefStream({
+            header: this.header.clone(),
+            original: new Uint8Array(this.original),
+        });
+    }
+}

package/dist/core/objects/pdf-string.d.ts

@@ -0,0 +1,15 @@
+import { ByteArray } from '../../types';
+import { PdfStringToken } from '../tokens/string-token';
+import { PdfObject } from './pdf-object';
+export declare class PdfString extends PdfObject {
+    /**
+     * The raw bytes of the PDF string.
+     */
+    private _raw;
+    constructor(raw: ByteArray | string);
+    get raw(): ByteArray;
+    set raw(raw: ByteArray);
+    get value(): string;
+    protected tokenize(): PdfStringToken[];
+    clone(): this;
+}

package/dist/core/objects/pdf-string.js

@@ -0,0 +1,30 @@
+import { bytesToString } from '../../utils/bytesToString';
+import { stringToBytes } from '../../utils/stringToBytes';
+import { PdfStringToken } from '../tokens/string-token';
+import { PdfObject } from './pdf-object';
+export class PdfString extends PdfObject {
+    /**
+     * The raw bytes of the PDF string.
+     */
+    _raw;
+    constructor(raw) {
+        super();
+        this._raw = typeof raw === 'string' ? stringToBytes(raw) : raw;
+    }
+    get raw() {
+        return this._raw;
+    }
+    set raw(raw) {
+        this.setModified();
+        this._raw = raw;
+    }
+    get value() {
+        return bytesToString(this.raw);
+    }
+    tokenize() {
+        return [new PdfStringToken(this.raw)];
+    }
+    clone() {
+        return new PdfString(new Uint8Array(this.raw));
+    }
+}

package/dist/core/objects/pdf-trailer.d.ts

@@ -0,0 +1,26 @@
+import { Ref } from '../ref';
+import { PdfToken } from '../tokens/token';
+import { PdfArray } from './pdf-array';
+import { PdfDictionary } from './pdf-dictionary';
+import { PdfHexadecimal } from './pdf-hexadecimal';
+import { PdfNumber } from './pdf-number';
+import { PdfObject } from './pdf-object';
+import { PdfObjectReference } from './pdf-object-reference';
+export type PdfTrailerEntries = {
+    Size: PdfNumber;
+    Root?: PdfObjectReference;
+    Info?: PdfObjectReference;
+    Prev?: PdfNumber;
+    XRefStm?: PdfNumber;
+    Encrypt?: PdfObjectReference;
+    ID?: PdfArray<PdfHexadecimal>;
+};
+export type PdfTrailerDictionary = PdfDictionary<PdfTrailerEntries>;
+export declare class PdfTrailer extends PdfObject {
+    dict: PdfTrailerDictionary;
+    offset: Ref<number>;
+    constructor(entries: PdfTrailerEntries | PdfDictionary<PdfTrailerEntries>);
+    protected tokenize(): PdfToken[];
+    clone(): this;
+    isModified(): boolean;
+}