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

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

@@ -0,0 +1,136 @@
+import { PdfEndDictionaryToken } from '../tokens/end-dictionary-token';
+import { PdfStartDictionaryToken } from '../tokens/start-dictionary-token';
+import { PdfWhitespaceToken } from '../tokens/whitespace-token';
+import { PdfName } from './pdf-name';
+import { PdfObject } from './pdf-object';
+export class PdfDictionary extends PdfObject {
+    #entries;
+    innerTokens = [];
+    constructor(entries) {
+        super();
+        this.#entries = entries instanceof Map ? entries : new Map();
+        if (entries) {
+            for (const [key, value] of Object.entries(entries)) {
+                this.#entries.set(new PdfName(key), value);
+            }
+        }
+    }
+    get(key) {
+        if (key instanceof PdfName) {
+            return this.#entries.get(key);
+        }
+        else {
+            for (const [k, v] of this.#entries) {
+                if (k.value === key) {
+                    return v;
+                }
+            }
+        }
+    }
+    set(key, value) {
+        const currentValue = this.get(key);
+        if (currentValue !== value && !currentValue?.equals(value)) {
+            this.modified = true;
+        }
+        if (key instanceof PdfName) {
+            this.#entries.set(key, value);
+            return;
+        }
+        else {
+            for (const k of this.#entries.keys()) {
+                if (k.value === key) {
+                    this.#entries.set(k, value);
+                    return;
+                }
+            }
+        }
+        this.#entries.set(new PdfName(key), value);
+    }
+    delete(key) {
+        if (this.has(key)) {
+            this.modified = true;
+        }
+        if (key instanceof PdfName) {
+            this.#entries.delete(key);
+            return;
+        }
+        else {
+            for (const k of this.#entries.keys()) {
+                if (k.value === key) {
+                    this.#entries.delete(k);
+                    return;
+                }
+            }
+        }
+    }
+    has(key) {
+        if (key instanceof PdfName) {
+            return this.#entries.has(key);
+        }
+        else {
+            for (const k of this.#entries.keys()) {
+                if (k.value === key) {
+                    return true;
+                }
+            }
+        }
+        return false;
+    }
+    get values() {
+        const obj = {};
+        for (const [key, value] of this.#entries) {
+            obj[key.value] = value;
+        }
+        return obj;
+    }
+    tokenize() {
+        let index = 0;
+        const entries = Array.from(this.#entries.entries()).flatMap(([key, value]) => {
+            if (value === undefined) {
+                return [];
+            }
+            const preTokens = key.preTokens
+                ? []
+                : index === 0
+                    ? [PdfWhitespaceToken.SPACE]
+                    : [];
+            const centralTokens = key.postTokens || value.preTokens
+                ? []
+                : [PdfWhitespaceToken.SPACE];
+            const postTokens = value.postTokens
+                ? []
+                : [PdfWhitespaceToken.SPACE];
+            index++;
+            return [
+                ...preTokens,
+                ...key.toTokens(),
+                ...centralTokens,
+                ...value.toTokens(),
+                ...postTokens,
+            ];
+        });
+        return [
+            new PdfStartDictionaryToken(),
+            ...this.innerTokens,
+            ...entries,
+            new PdfEndDictionaryToken(),
+        ];
+    }
+    copyFrom(other) {
+        for (const [key, value] of other.#entries) {
+            this.#entries.set(key, value);
+        }
+        this.modified = true;
+    }
+    clone() {
+        const clonedEntries = new Map();
+        for (const [key, value] of this.#entries) {
+            clonedEntries.set(key.clone(), value ? value.clone() : undefined);
+        }
+        return new PdfDictionary(clonedEntries);
+    }
+    isModified() {
+        return (super.isModified() ||
+            Array.from(this.#entries.values()).some((v) => v?.isModified()));
+    }
+}

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

@@ -0,0 +1,17 @@
+import { ByteArray } from '../../types';
+import { PdfHexadecimalToken } from '../tokens/hexadecimal-token';
+import { PdfObject } from './pdf-object';
+export declare class PdfHexadecimal extends PdfObject {
+    /**
+     * The raw byte value represented by this hexadecimal object.
+     * NB: This is  the hexadecimal representation, not the actual byte values.
+     */
+    raw: ByteArray;
+    constructor(value: string | ByteArray, format?: 'hex' | 'bytes');
+    static toHexadecimal(data: string | ByteArray): PdfHexadecimal;
+    get bytes(): ByteArray;
+    toHexBytes(): ByteArray;
+    toHexString(): string;
+    protected tokenize(): PdfHexadecimalToken[];
+    clone(): this;
+}

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

@@ -0,0 +1,42 @@
+import { bytesToHexBytes } from '../../utils/bytesToHexBytes';
+import { bytesToString } from '../../utils/bytesToString';
+import { hexBytesToBytes } from '../../utils/hexBytesToBytes';
+import { stringToBytes } from '../../utils/stringToBytes';
+import { PdfHexadecimalToken } from '../tokens/hexadecimal-token';
+import { PdfObject } from './pdf-object';
+export class PdfHexadecimal extends PdfObject {
+    /**
+     * The raw byte value represented by this hexadecimal object.
+     * NB: This is  the hexadecimal representation, not the actual byte values.
+     */
+    raw;
+    constructor(value, format = 'hex') {
+        super();
+        let bytes;
+        if (format === 'bytes') {
+            bytes = bytesToHexBytes(value instanceof Uint8Array ? value : stringToBytes(value));
+        }
+        else {
+            bytes = value instanceof Uint8Array ? value : stringToBytes(value);
+        }
+        this.raw = bytes;
+    }
+    static toHexadecimal(data) {
+        return new PdfHexadecimal(data, 'bytes');
+    }
+    get bytes() {
+        return hexBytesToBytes(this.raw);
+    }
+    toHexBytes() {
+        return bytesToHexBytes(this.raw);
+    }
+    toHexString() {
+        return bytesToString(this.toHexBytes());
+    }
+    tokenize() {
+        return [new PdfHexadecimalToken(this.raw)];
+    }
+    clone() {
+        return new PdfHexadecimal(new Uint8Array(this.raw));
+    }
+}

package/dist/core/objects/pdf-indirect-object.d.ts

@@ -0,0 +1,27 @@
+import { PdfNull } from './pdf-null';
+import { PdfObject } from './pdf-object';
+import { PdfObjectReference } from './pdf-object-reference';
+import { Ref } from '../ref';
+export declare class PdfIndirectObject<T extends PdfObject = PdfObject> extends PdfObjectReference {
+    static readonly MAX_ORDER_INDEX = 2147483647;
+    content: T;
+    offset: Ref<number>;
+    encryptable?: boolean;
+    orderIndex?: number;
+    constructor(options: {
+        objectNumber?: number;
+        generationNumber?: number;
+        content: T;
+        offset?: number | Ref<number>;
+        encryptable?: boolean;
+    } | T);
+    get reference(): PdfObjectReference;
+    isEncryptable(): boolean;
+    static createPlaceholder<T extends PdfObject>(objectNumber?: number, generationNumber?: number, content?: T): PdfIndirectObject<T extends unknown ? PdfNull : T>;
+    inPdf(): boolean;
+    matchesReference(ref?: PdfObjectReference): boolean;
+    protected tokenize(): import("../tokens/token").PdfToken[];
+    clone(): this;
+    order(): number;
+    isModified(): boolean;
+}

package/dist/core/objects/pdf-indirect-object.js

@@ -0,0 +1,100 @@
+import { PdfEndObjectToken } from '../tokens/end-object-token';
+import { PdfStartObjectToken } from '../tokens/start-object-token';
+import { PdfWhitespaceToken } from '../tokens/whitespace-token';
+import { PdfNull } from './pdf-null';
+import { PdfObject } from './pdf-object';
+import { PdfObjectReference } from './pdf-object-reference';
+import { PdfStream } from './pdf-stream';
+import { Ref } from '../ref';
+import { PdfByteOffsetToken } from '../tokens/byte-offset-token';
+export class PdfIndirectObject extends PdfObjectReference {
+    static MAX_ORDER_INDEX = 2147483647;
+    content;
+    offset;
+    encryptable;
+    orderIndex;
+    constructor(options) {
+        if (options instanceof PdfObject) {
+            super(-1, 0);
+            this.content = options;
+            this.offset = new Ref(0);
+            return;
+        }
+        super(options.objectNumber ?? -1, options.generationNumber ?? 0);
+        this.content = options.content;
+        this.offset =
+            options.offset instanceof Ref
+                ? options.offset
+                : new Ref(options.offset ?? 0);
+        this.encryptable = options.encryptable;
+    }
+    get reference() {
+        return new Proxy(this, {
+            get: (target, prop) => {
+                const value = new PdfObjectReference(target.objectNumber, target.generationNumber);
+                if (prop === 'objectNumber') {
+                    return target.objectNumber;
+                }
+                else if (prop === 'generationNumber') {
+                    return target.generationNumber;
+                }
+                else {
+                    return value[prop];
+                }
+            },
+        });
+    }
+    isEncryptable() {
+        if (this.encryptable === undefined) {
+            if (this.content instanceof PdfStream &&
+                this.content.isType('XRef')) {
+                return false;
+            }
+        }
+        return this.encryptable ?? true;
+    }
+    static createPlaceholder(objectNumber, generationNumber, content) {
+        return new PdfIndirectObject({
+            objectNumber: objectNumber ?? -1,
+            generationNumber: generationNumber ?? 0,
+            content: content ?? new PdfNull(),
+            offset: -1,
+        });
+    }
+    inPdf() {
+        return this.objectNumber >= 1;
+    }
+    matchesReference(ref) {
+        if (!ref) {
+            return false;
+        }
+        return (this.objectNumber === ref.objectNumber &&
+            this.generationNumber === ref.generationNumber);
+    }
+    tokenize() {
+        return [
+            new PdfByteOffsetToken(this.offset),
+            new PdfStartObjectToken(this.objectNumber, this.generationNumber),
+            ...(this.content.preTokens ? [] : [PdfWhitespaceToken.NEWLINE]),
+            ...this.content.toTokens(),
+            ...(this.content.postTokens ? [] : [PdfWhitespaceToken.NEWLINE]),
+            new PdfEndObjectToken(),
+        ];
+    }
+    clone() {
+        return new PdfIndirectObject({
+            objectNumber: this.objectNumber,
+            generationNumber: this.generationNumber,
+            content: this.content.clone(),
+            offset: this.offset.resolve(),
+        });
+    }
+    order() {
+        return this.orderIndex ?? 0;
+    }
+    isModified() {
+        return (super.isModified() ||
+            this.content.isModified() ||
+            this.offset.isModified);
+    }
+}

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

@@ -0,0 +1,8 @@
+import { PdfNameToken } from '../tokens/name-token';
+import { PdfObject } from './pdf-object';
+export declare class PdfName<T extends string = string> extends PdfObject {
+    value: T;
+    constructor(value: T);
+    protected tokenize(): PdfNameToken[];
+    clone(): this;
+}

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

@@ -0,0 +1,15 @@
+import { PdfNameToken } from '../tokens/name-token';
+import { PdfObject } from './pdf-object';
+export class PdfName extends PdfObject {
+    value;
+    constructor(value) {
+        super();
+        this.value = value;
+    }
+    tokenize() {
+        return [new PdfNameToken(this.value)];
+    }
+    clone() {
+        return new PdfName(this.value);
+    }
+}

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

@@ -0,0 +1,7 @@
+import { PdfObject } from './pdf-object';
+import { PdfNullToken } from '../tokens/null-token';
+export declare class PdfNull extends PdfObject {
+    static readonly NULL: PdfNull;
+    protected tokenize(): PdfNullToken[];
+    clone(): this;
+}

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

@@ -0,0 +1,11 @@
+import { PdfObject } from './pdf-object';
+import { PdfNullToken } from '../tokens/null-token';
+export class PdfNull extends PdfObject {
+    static NULL = new PdfNull();
+    tokenize() {
+        return [new PdfNullToken()];
+    }
+    clone() {
+        return new PdfNull();
+    }
+}

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

@@ -0,0 +1,25 @@
+import { Ref } from '../ref';
+import { PdfNumberToken } from '../tokens/number-token';
+import { PdfObject } from './pdf-object';
+export declare class PdfNumber extends PdfObject {
+    #private;
+    padTo: number;
+    decimalPlaces: number;
+    isByteOffset: boolean;
+    constructor(options?: {
+        value: number | Ref<number>;
+        padTo?: number;
+        decimalPlaces?: number;
+    } | number | Ref<number> | PdfNumber);
+    get ref(): Ref<number>;
+    get value(): number;
+    set value(value: number);
+    onChange(callback: (value: number) => void): void;
+    toToken(): PdfNumberToken;
+    protected tokenize(): PdfNumberToken[];
+    clone(): this;
+    isModified(): boolean;
+}
+export declare class PdfByteOffsetNumber extends PdfNumber {
+    isByteOffset: boolean;
+}

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

@@ -0,0 +1,77 @@
+import { Ref } from '../ref';
+import { PdfNumberToken } from '../tokens/number-token';
+import { PdfObject } from './pdf-object';
+export class PdfNumber extends PdfObject {
+    #value;
+    padTo;
+    decimalPlaces;
+    isByteOffset = false;
+    constructor(options = 0) {
+        super();
+        if (options instanceof Ref) {
+            this.#value = options;
+            this.padTo = 0;
+            this.decimalPlaces = 0;
+        }
+        else if (options instanceof PdfNumber) {
+            this.#value = options.ref;
+            this.padTo = options.padTo;
+            this.decimalPlaces = options.decimalPlaces;
+            this.preTokens = options.preTokens;
+            this.postTokens = options.postTokens;
+        }
+        else if (typeof options === 'number') {
+            this.#value = new Ref(options);
+            this.padTo = 0;
+            this.decimalPlaces = 0;
+        }
+        else {
+            this.#value =
+                typeof options.value === 'number'
+                    ? new Ref(options.value)
+                    : options.value;
+            this.padTo = options.padTo ?? 0;
+            this.decimalPlaces = options.decimalPlaces ?? 0;
+        }
+        if (this.value === Number.POSITIVE_INFINITY ||
+            this.value === Number.NEGATIVE_INFINITY) {
+            throw new Error('PDF numbers cannot be infinite');
+        }
+    }
+    get ref() {
+        return this.#value;
+    }
+    get value() {
+        return this.#value.resolve();
+    }
+    set value(value) {
+        this.#value.update(value);
+    }
+    onChange(callback) {
+        this.#value.onUpdate(callback);
+    }
+    toToken() {
+        return new PdfNumberToken({
+            value: this.#value,
+            padTo: this.padTo,
+            decimalPlaces: this.decimalPlaces,
+            isByteToken: this.isByteOffset,
+        });
+    }
+    tokenize() {
+        return [this.toToken()];
+    }
+    clone() {
+        return new PdfNumber({
+            value: this.value,
+            padTo: this.padTo,
+            decimalPlaces: this.decimalPlaces,
+        });
+    }
+    isModified() {
+        return super.isModified() || this.#value.isModified;
+    }
+}
+export class PdfByteOffsetNumber extends PdfNumber {
+    isByteOffset = true;
+}

package/dist/core/objects/pdf-object-reference.d.ts

@@ -0,0 +1,9 @@
+import { PdfToken } from '../tokens/token';
+import { PdfObject } from './pdf-object';
+export declare class PdfObjectReference extends PdfObject {
+    objectNumber: number;
+    generationNumber: number;
+    constructor(objectNumber: number, generationNumber: number);
+    protected tokenize(): PdfToken[];
+    clone(): this;
+}

package/dist/core/objects/pdf-object-reference.js

@@ -0,0 +1,19 @@
+import { PdfObjectReferenceToken } from '../tokens/object-reference-token';
+import { PdfObject } from './pdf-object';
+export class PdfObjectReference extends PdfObject {
+    objectNumber;
+    generationNumber;
+    constructor(objectNumber, generationNumber) {
+        super();
+        this.objectNumber = objectNumber;
+        this.generationNumber = generationNumber;
+    }
+    tokenize() {
+        return [
+            new PdfObjectReferenceToken(this.objectNumber, this.generationNumber),
+        ];
+    }
+    clone() {
+        return new PdfObjectReference(this.objectNumber, this.generationNumber);
+    }
+}

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

@@ -0,0 +1,30 @@
+import { ByteArray } from '../../types.js';
+import { PdfToken } from '../tokens/token.js';
+export declare abstract class PdfObject {
+    /** Optional tokens to prepend or append during serialization */
+    preTokens?: PdfToken[];
+    /** Optional tokens to prepend or append during serialization */
+    postTokens?: PdfToken[];
+    /** Indicates whether the object has been modified. By default, assume it has been modified because it's a new object */
+    protected modified: boolean;
+    /** Tokenizes the object into an array of PdfTokens */
+    protected abstract tokenize(): PdfToken[];
+    /** The type of this PDF object */
+    get objectType(): string;
+    /** Indicates whether the object has been modified. Override this method if the modified state is determined differently */
+    isModified(): boolean;
+    /** Sets the modified state of the object. Override this method if the modified state is determined differently */
+    setModified(modified?: boolean): void;
+    /** Converts the object to an array of PdfTokens, including any pre or post tokens */
+    toTokens(): PdfToken[];
+    /** Converts the object to a ByteArray, optionally padding to a specified length */
+    toBytes(padTo?: number): ByteArray;
+    /** Converts the object to a string representation */
+    toString(): string;
+    /** Attempts to cast the object to a specific PdfObject subclass */
+    as<T extends PdfObject>(ctor: new (...args: any[]) => T): T;
+    /** Creates a deep clone of the object */
+    abstract clone(): this;
+    /** Compares this object to another for equality based on their token representations */
+    equals(other?: PdfObject): boolean;
+}

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

@@ -0,0 +1,77 @@
+import { concatUint8Arrays } from '../../utils/concatUint8Arrays.js';
+import { PdfWhitespaceToken } from '../tokens/whitespace-token.js';
+export class PdfObject {
+    /** Optional tokens to prepend or append during serialization */
+    preTokens;
+    /** Optional tokens to prepend or append during serialization */
+    postTokens;
+    /** Indicates whether the object has been modified. By default, assume it has been modified because it's a new object */
+    modified = true;
+    /** The type of this PDF object */
+    get objectType() {
+        return this.constructor.name;
+    }
+    /** Indicates whether the object has been modified. Override this method if the modified state is determined differently */
+    isModified() {
+        return this.modified;
+    }
+    /** Sets the modified state of the object. Override this method if the modified state is determined differently */
+    setModified(modified = true) {
+        this.modified = modified;
+    }
+    /** Converts the object to an array of PdfTokens, including any pre or post tokens */
+    toTokens() {
+        return [
+            ...(this.preTokens ?? []),
+            ...this.tokenize(),
+            ...(this.postTokens ?? []),
+        ];
+    }
+    /** Converts the object to a ByteArray, optionally padding to a specified length */
+    toBytes(padTo) {
+        const tokens = this.toTokens();
+        const byteArray = concatUint8Arrays(...tokens.map((token) => token.toBytes()));
+        if (padTo) {
+            const paddedArray = new Uint8Array(padTo);
+            paddedArray.set(byteArray);
+            return paddedArray;
+        }
+        return byteArray;
+    }
+    /** Converts the object to a string representation */
+    toString() {
+        let str = '';
+        for (const byte of this.toBytes()) {
+            str += String.fromCharCode(byte);
+        }
+        return str;
+    }
+    /** Attempts to cast the object to a specific PdfObject subclass */
+    as(ctor) {
+        if (this instanceof ctor) {
+            return this;
+        }
+        throw new Error(`Cannot cast object of type ${this.objectType} to ${ctor.name}`);
+    }
+    /** Compares this object to another for equality based on their token representations */
+    equals(other) {
+        if (!other) {
+            return false;
+        }
+        const tokensA = this.toTokens().filter((x) => !(x instanceof PdfWhitespaceToken));
+        const tokensB = other
+            .toTokens()
+            .filter((x) => !(x instanceof PdfWhitespaceToken));
+        if (tokensA.length !== tokensB.length) {
+            return false;
+        }
+        for (let i = 0; i < tokensA.length; i++) {
+            const tokenA = tokensA[i];
+            const tokenB = tokensB[i];
+            if (!tokenA.equals(tokenB)) {
+                return false;
+            }
+        }
+        return true;
+    }
+}

package/dist/core/objects/pdf-start-xref.d.ts

@@ -0,0 +1,10 @@
+import { Ref } from '../ref';
+import { PdfNumber } from './pdf-number';
+import { PdfObject } from './pdf-object';
+export declare class PdfStartXRef extends PdfObject {
+    offset: PdfNumber;
+    constructor(offset?: number | PdfNumber | Ref<number>);
+    protected tokenize(): import("../tokens/token").PdfToken[];
+    clone(): this;
+    isModified(): boolean;
+}

package/dist/core/objects/pdf-start-xref.js

@@ -0,0 +1,32 @@
+import { PdfStartXRefToken } from '../tokens/start-xref-token';
+import { PdfWhitespaceToken } from '../tokens/whitespace-token';
+import { PdfNumber } from './pdf-number';
+import { PdfObject } from './pdf-object';
+export class PdfStartXRef extends PdfObject {
+    offset;
+    constructor(offset = -1) {
+        // default to -1 for unknown offset
+        super();
+        this.offset =
+            offset instanceof PdfNumber
+                ? offset
+                : new PdfNumber({ value: offset });
+        this.offset.isByteOffset = true;
+    }
+    tokenize() {
+        const whiteSpaceTokens = this.offset.preTokens
+            ? []
+            : [PdfWhitespaceToken.NEWLINE];
+        return [
+            new PdfStartXRefToken(),
+            ...whiteSpaceTokens,
+            ...this.offset.toTokens(),
+        ];
+    }
+    clone() {
+        return new PdfStartXRef(this.offset.clone());
+    }
+    isModified() {
+        return super.isModified() || this.offset.isModified();
+    }
+}