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

package/dist/core/tokens/comment-token.d.ts

@@ -0,0 +1,10 @@
+import { PdfToken } from './token';
+import { ByteArray } from '../../types';
+export declare class PdfCommentToken extends PdfToken {
+    static EOF: PdfCommentToken;
+    comment: ByteArray;
+    constructor(comment: ByteArray | string);
+    get innerComment(): string;
+    private static toBytes;
+    static isEofCommentToken(token: PdfToken): boolean;
+}

package/dist/core/tokens/comment-token.js

@@ -0,0 +1,26 @@
+import { stringToBytes } from '../../utils/stringToBytes';
+import { concatUint8Arrays } from '../../utils/concatUint8Arrays';
+import { PdfToken } from './token';
+import { bytesToString } from '../../utils/bytesToString';
+export class PdfCommentToken extends PdfToken {
+    static EOF = new PdfCommentToken('%EOF');
+    comment;
+    constructor(comment) {
+        super(PdfCommentToken.toBytes(comment));
+        this.comment =
+            typeof comment === 'string' ? stringToBytes(comment) : comment;
+    }
+    get innerComment() {
+        return bytesToString(this.comment);
+    }
+    static toBytes(comment) {
+        const tokenBytes = typeof comment === 'string' ? stringToBytes(comment) : comment;
+        return concatUint8Arrays(stringToBytes('%'), tokenBytes);
+    }
+    static isEofCommentToken(token) {
+        if (!(token instanceof PdfCommentToken))
+            return false;
+        const tokenStr = token.innerComment.trim();
+        return tokenStr.toLowerCase() === '%eof';
+    }
+}

package/dist/core/tokens/end-array-token.d.ts

@@ -0,0 +1,4 @@
+import { PdfToken } from './token';
+export declare class PdfEndArrayToken extends PdfToken {
+    constructor();
+}

package/dist/core/tokens/end-array-token.js

@@ -0,0 +1,8 @@
+import { stringToBytes } from '../../utils/stringToBytes';
+import { PdfToken } from './token';
+const END_ARRAY_BYTES = stringToBytes(']');
+export class PdfEndArrayToken extends PdfToken {
+    constructor() {
+        super(END_ARRAY_BYTES);
+    }
+}

package/dist/core/tokens/end-dictionary-token.d.ts

@@ -0,0 +1,4 @@
+import { PdfToken } from './token';
+export declare class PdfEndDictionaryToken extends PdfToken {
+    constructor();
+}

package/dist/core/tokens/end-dictionary-token.js

@@ -0,0 +1,8 @@
+import { stringToBytes } from '../../utils/stringToBytes';
+import { PdfToken } from './token';
+const END_DICTIONARY_BYTES = stringToBytes('>>');
+export class PdfEndDictionaryToken extends PdfToken {
+    constructor() {
+        super(END_DICTIONARY_BYTES);
+    }
+}

package/dist/core/tokens/end-object-token.d.ts

@@ -0,0 +1,4 @@
+import { PdfToken } from './token';
+export declare class PdfEndObjectToken extends PdfToken {
+    constructor();
+}

package/dist/core/tokens/end-object-token.js

@@ -0,0 +1,8 @@
+import { stringToBytes } from '../../utils/stringToBytes';
+import { PdfToken } from './token';
+const END_OBJECT_BYTES = stringToBytes('endobj');
+export class PdfEndObjectToken extends PdfToken {
+    constructor() {
+        super(END_OBJECT_BYTES);
+    }
+}

package/dist/core/tokens/end-stream-token.d.ts

@@ -0,0 +1,5 @@
+import { ByteArray } from '../../types';
+import { PdfToken } from './token';
+export declare class PdfEndStreamToken extends PdfToken {
+    constructor(bytes?: ByteArray);
+}

package/dist/core/tokens/end-stream-token.js

@@ -0,0 +1,8 @@
+import { stringToBytes } from '../../utils/stringToBytes';
+import { PdfToken } from './token';
+const END_STREAM_BYTES = stringToBytes('endstream');
+export class PdfEndStreamToken extends PdfToken {
+    constructor(bytes) {
+        super(bytes ?? END_STREAM_BYTES);
+    }
+}

package/dist/core/tokens/hexadecimal-token.d.ts

@@ -0,0 +1,7 @@
+import { ByteArray } from '../../types';
+import { PdfToken } from './token';
+export declare class PdfHexadecimalToken extends PdfToken {
+    raw: ByteArray;
+    constructor(hexadecimal: string | ByteArray);
+    private static toBytes;
+}

package/dist/core/tokens/hexadecimal-token.js

@@ -0,0 +1,16 @@
+import { stringToBytes } from '../../utils/stringToBytes';
+import { PdfToken } from './token';
+export class PdfHexadecimalToken extends PdfToken {
+    raw;
+    constructor(hexadecimal) {
+        super(PdfHexadecimalToken.toBytes(hexadecimal));
+        this.raw =
+            typeof hexadecimal === 'string'
+                ? stringToBytes(hexadecimal)
+                : hexadecimal;
+    }
+    static toBytes(hexadecimal) {
+        const bytes = stringToBytes(hexadecimal);
+        return new Uint8Array([0x3c, ...bytes, 0x3e]);
+    }
+}

package/dist/core/tokens/name-token.d.ts

@@ -0,0 +1,6 @@
+import { PdfToken } from './token';
+export declare class PdfNameToken extends PdfToken {
+    name: string;
+    constructor(name: string);
+    private static toBytes;
+}

package/dist/core/tokens/name-token.js

@@ -0,0 +1,15 @@
+import { stringToBytes } from '../../utils/stringToBytes';
+import { PdfToken } from './token';
+export class PdfNameToken extends PdfToken {
+    name;
+    constructor(name) {
+        if (typeof name !== 'string' || name.length === 0) {
+            throw new Error('PdfNameToken name must be a non-empty string');
+        }
+        super(PdfNameToken.toBytes(name));
+        this.name = name;
+    }
+    static toBytes(name) {
+        return stringToBytes(`/${name}`);
+    }
+}

package/dist/core/tokens/null-token.d.ts

@@ -0,0 +1,4 @@
+import { PdfToken } from './token';
+export declare class PdfNullToken extends PdfToken {
+    constructor();
+}

package/dist/core/tokens/null-token.js

@@ -0,0 +1,8 @@
+import { stringToBytes } from '../../utils/stringToBytes';
+import { PdfToken } from './token';
+const NULL = stringToBytes('null');
+export class PdfNullToken extends PdfToken {
+    constructor() {
+        super(NULL);
+    }
+}

package/dist/core/tokens/number-token.d.ts

@@ -0,0 +1,24 @@
+import { ByteArray } from '../../types';
+import { Ref } from '../ref';
+import { PdfToken } from './token';
+export declare class PdfNumberToken extends PdfToken {
+    #private;
+    padTo: number;
+    decimalPlaces: number;
+    isByteToken: boolean;
+    constructor(options: {
+        value: number | ByteArray | PdfNumberToken | Ref<number>;
+        padTo?: number;
+        decimalPlaces?: number;
+        isByteToken?: boolean;
+    } | number | ByteArray, padTo?: number, decimalPlaces?: number);
+    toBytes(): ByteArray;
+    get ref(): Ref<number>;
+    set ref(newRef: Ref<number>);
+    get value(): number;
+    set value(newValue: number);
+    static getValue(bytes: ByteArray | PdfNumberToken | number | Ref<number>): Ref<number>;
+    static getPadding(bytes: ByteArray | PdfNumberToken | number | Ref<number>): number;
+    static getDecimalPlaces(bytes: ByteArray | PdfNumberToken | number | Ref<number>): number;
+    static toBytes(value: number | PdfNumberToken | Ref<number> | ByteArray, padTo?: number, decimalPlaces?: number): ByteArray;
+}

package/dist/core/tokens/number-token.js

@@ -0,0 +1,104 @@
+import { stringToBytes } from '../../utils/stringToBytes';
+import { Ref } from '../ref';
+import { PdfToken } from './token';
+export class PdfNumberToken extends PdfToken {
+    #value;
+    padTo;
+    decimalPlaces;
+    isByteToken = false;
+    constructor(options, padTo, decimalPlaces) {
+        super();
+        if (typeof options === 'number' ||
+            options instanceof Uint8Array ||
+            options instanceof Ref ||
+            options instanceof PdfNumberToken) {
+            this.#value = PdfNumberToken.getValue(options);
+            this.padTo = padTo ?? 0;
+            this.decimalPlaces = decimalPlaces ?? 0;
+            this.isByteToken = false;
+            return;
+        }
+        this.#value = PdfNumberToken.getValue(options.value);
+        this.padTo = options.padTo ?? 0;
+        this.decimalPlaces =
+            options.decimalPlaces ??
+                PdfNumberToken.getDecimalPlaces(options.value);
+        this.isByteToken = options.isByteToken ?? false;
+    }
+    toBytes() {
+        return PdfNumberToken.toBytes(this.#value, this.padTo, this.decimalPlaces);
+    }
+    get ref() {
+        return this.#value;
+    }
+    set ref(newRef) {
+        this.#value = newRef;
+    }
+    get value() {
+        return this.#value.resolve();
+    }
+    set value(newValue) {
+        this.#value.update(newValue);
+    }
+    static getValue(bytes) {
+        if (bytes instanceof Ref) {
+            return bytes;
+        }
+        if (bytes instanceof PdfNumberToken) {
+            return bytes.ref;
+        }
+        if (typeof bytes === 'number') {
+            return new Ref(bytes);
+        }
+        const str = new TextDecoder().decode(bytes);
+        return new Ref(parseFloat(str));
+    }
+    static getPadding(bytes) {
+        if (bytes instanceof PdfNumberToken) {
+            return bytes.padTo;
+        }
+        if (bytes instanceof Ref) {
+            bytes = PdfNumberToken.toBytes(bytes.resolve());
+        }
+        if (typeof bytes === 'number') {
+            bytes = PdfNumberToken.toBytes(bytes);
+        }
+        let padding = 0;
+        while (bytes.length && bytes[0] === 0x30) {
+            bytes = bytes.slice(1);
+            padding++;
+        }
+        return padding;
+    }
+    static getDecimalPlaces(bytes) {
+        if (bytes instanceof PdfNumberToken) {
+            return bytes.decimalPlaces;
+        }
+        if (bytes instanceof Ref) {
+            bytes = PdfNumberToken.toBytes(bytes.resolve());
+        }
+        if (typeof bytes === 'number') {
+            bytes = PdfNumberToken.toBytes(bytes);
+        }
+        const str = new TextDecoder().decode(bytes);
+        const match = str.match(/\.(\d+)/);
+        if (match) {
+            return match[1].length;
+        }
+        return 0;
+    }
+    static toBytes(value, padTo, decimalPlaces) {
+        if (value instanceof Uint8Array) {
+            return value;
+        }
+        if (value instanceof PdfNumberToken) {
+            return value.toBytes();
+        }
+        const numberValue = value instanceof Ref ? value.resolve() : value;
+        const valueString = decimalPlaces
+            ? numberValue.toFixed(decimalPlaces)
+            : numberValue.toString();
+        const tokenString = valueString.padStart(padTo ?? 0, '0');
+        return stringToBytes(tokenString);
+    }
+}

package/dist/core/tokens/object-reference-token.d.ts

@@ -0,0 +1,7 @@
+import { PdfToken } from './token';
+export declare class PdfObjectReferenceToken extends PdfToken {
+    objectNumber: number;
+    generationNumber: number;
+    constructor(objectNumber: number, generationNumber: number);
+    private static toBytes;
+}

package/dist/core/tokens/object-reference-token.js

@@ -0,0 +1,17 @@
+import { stringToBytes } from '../../utils/stringToBytes';
+import { PdfToken } from './token';
+export class PdfObjectReferenceToken extends PdfToken {
+    objectNumber;
+    generationNumber;
+    constructor(objectNumber, generationNumber) {
+        super(PdfObjectReferenceToken.toBytes(objectNumber, generationNumber));
+        this.objectNumber = objectNumber;
+        this.generationNumber = generationNumber;
+    }
+    static toBytes(objectNumber, generationNumber) {
+        const objNumStr = objectNumber.toString();
+        const genNumStr = generationNumber.toString();
+        const refStr = `${objNumStr} ${genNumStr} R`;
+        return stringToBytes(refStr);
+    }
+}

package/dist/core/tokens/start-array-token.d.ts

@@ -0,0 +1,4 @@
+import { PdfToken } from './token';
+export declare class PdfStartArrayToken extends PdfToken {
+    constructor();
+}

package/dist/core/tokens/start-array-token.js

@@ -0,0 +1,8 @@
+import { stringToBytes } from '../../utils/stringToBytes';
+import { PdfToken } from './token';
+const START_ARRAY_BYTES = stringToBytes('[');
+export class PdfStartArrayToken extends PdfToken {
+    constructor() {
+        super(START_ARRAY_BYTES);
+    }
+}

package/dist/core/tokens/start-dictionary-token.d.ts

@@ -0,0 +1,4 @@
+import { PdfToken } from './token';
+export declare class PdfStartDictionaryToken extends PdfToken {
+    constructor();
+}

package/dist/core/tokens/start-dictionary-token.js

@@ -0,0 +1,8 @@
+import { stringToBytes } from '../../utils/stringToBytes';
+import { PdfToken } from './token';
+const START_DICTIONARY_BYTES = stringToBytes('<<');
+export class PdfStartDictionaryToken extends PdfToken {
+    constructor() {
+        super(START_DICTIONARY_BYTES);
+    }
+}

package/dist/core/tokens/start-object-token.d.ts

@@ -0,0 +1,8 @@
+import { PdfToken } from './token';
+export declare class PdfStartObjectToken extends PdfToken {
+    objectNumber: number;
+    generationNumber: number;
+    byteOffset?: number;
+    constructor(objectNumber: number, generationNumber: number, byteOffset?: number);
+    private static toBytes;
+}

package/dist/core/tokens/start-object-token.js

@@ -0,0 +1,17 @@
+import { stringToBytes } from '../../utils/stringToBytes';
+import { PdfToken } from './token';
+export class PdfStartObjectToken extends PdfToken {
+    objectNumber;
+    generationNumber;
+    byteOffset;
+    constructor(objectNumber, generationNumber, byteOffset) {
+        super(PdfStartObjectToken.toBytes(objectNumber, generationNumber));
+        this.objectNumber = objectNumber;
+        this.generationNumber = generationNumber;
+        this.byteOffset = byteOffset;
+    }
+    static toBytes(objectNumber, generationNumber) {
+        const tokenString = `${objectNumber} ${generationNumber} obj`;
+        return stringToBytes(tokenString);
+    }
+}

package/dist/core/tokens/start-stream-token.d.ts

@@ -0,0 +1,8 @@
+import { ByteArray } from '../../types';
+import { PdfToken } from './token';
+import { PdfWhitespaceToken } from './whitespace-token';
+export declare class PdfStartStreamToken extends PdfToken {
+    constructor(bytes?: ByteArray);
+    getTrailingWhitespaceTokens(): PdfWhitespaceToken[];
+    static withTrailingWhitespace(whitespaceTokens: PdfToken[] | undefined): PdfStartStreamToken;
+}

package/dist/core/tokens/start-stream-token.js

@@ -0,0 +1,38 @@
+import { stringToBytes } from '../../utils/stringToBytes';
+import { PdfToken } from './token';
+import { PdfWhitespaceToken } from './whitespace-token';
+const START_STREAM_WITHOUT_WHITESPACE_BYTES = stringToBytes('stream');
+const START_STREAM_BYTES = stringToBytes('stream\n');
+export class PdfStartStreamToken extends PdfToken {
+    constructor(bytes) {
+        super(bytes ?? START_STREAM_BYTES);
+    }
+    getTrailingWhitespaceTokens() {
+        const tokens = [];
+        const bytes = this.toBytes();
+        for (let i = bytes.length - 1; i >= 0; i--) {
+            const byte = bytes[i];
+            if (!PdfWhitespaceToken.isWhitespaceByte(byte)) {
+                continue;
+            }
+            tokens.push(new PdfWhitespaceToken(byte));
+        }
+        return tokens.reverse();
+    }
+    static withTrailingWhitespace(whitespaceTokens) {
+        if (!whitespaceTokens || whitespaceTokens.length === 0) {
+            return new PdfStartStreamToken();
+        }
+        const totalLength = START_STREAM_WITHOUT_WHITESPACE_BYTES.length +
+            whitespaceTokens.reduce((sum, token) => sum + token.byteLength, 0);
+        const bytes = new Uint8Array(totalLength);
+        bytes.set(START_STREAM_WITHOUT_WHITESPACE_BYTES, 0);
+        let offset = START_STREAM_WITHOUT_WHITESPACE_BYTES.length;
+        for (const token of whitespaceTokens) {
+            const tokenBytes = token.toBytes();
+            bytes.set(tokenBytes, offset);
+            offset += tokenBytes.length;
+        }
+        return new PdfStartStreamToken(bytes);
+    }
+}

package/dist/core/tokens/start-xref-token.d.ts

@@ -0,0 +1,4 @@
+import { PdfToken } from './token';
+export declare class PdfStartXRefToken extends PdfToken {
+    constructor();
+}

package/dist/core/tokens/start-xref-token.js

@@ -0,0 +1,8 @@
+import { stringToBytes } from '../../utils/stringToBytes';
+import { PdfToken } from './token';
+const START_XREF = stringToBytes('startxref');
+export class PdfStartXRefToken extends PdfToken {
+    constructor() {
+        super(START_XREF);
+    }
+}

package/dist/core/tokens/stream-chunk-token.d.ts

@@ -0,0 +1,5 @@
+import { ByteArray } from '../../types';
+import { PdfToken } from './token';
+export declare class PdfStreamChunkToken extends PdfToken {
+    constructor(bytes: ByteArray);
+}

package/dist/core/tokens/stream-chunk-token.js

@@ -0,0 +1,6 @@
+import { PdfToken } from './token';
+export class PdfStreamChunkToken extends PdfToken {
+    constructor(bytes) {
+        super(bytes);
+    }
+}

package/dist/core/tokens/string-token.d.ts

@@ -0,0 +1,7 @@
+import { ByteArray } from '../../types';
+import { PdfToken } from './token';
+export declare class PdfStringToken extends PdfToken {
+    value: ByteArray;
+    constructor(value: string | ByteArray);
+    private static toBytes;
+}

package/dist/core/tokens/string-token.js

@@ -0,0 +1,13 @@
+import { escapeString } from '../../utils/escapeString';
+import { stringToBytes } from '../../utils/stringToBytes';
+import { PdfToken } from './token';
+export class PdfStringToken extends PdfToken {
+    value;
+    constructor(value) {
+        super(PdfStringToken.toBytes(value));
+        this.value = typeof value === 'string' ? stringToBytes(value) : value;
+    }
+    static toBytes(value) {
+        return new Uint8Array([0x28, ...escapeString(value), 0x29]);
+    }
+}

package/dist/core/tokens/token.d.ts

@@ -0,0 +1,10 @@
+import { ByteArray } from '../../types';
+export declare abstract class PdfToken {
+    protected rawBytes: ByteArray;
+    constructor(bytes?: ByteArray);
+    toBytes(): ByteArray;
+    toString(): string;
+    get type(): string;
+    get byteLength(): number;
+    equals(other: PdfToken): boolean;
+}

package/dist/core/tokens/token.js

@@ -0,0 +1,32 @@
+import { bytesToString } from '../../utils/bytesToString';
+export class PdfToken {
+    rawBytes;
+    constructor(bytes) {
+        this.rawBytes = bytes ?? new Uint8Array();
+    }
+    toBytes() {
+        return this.rawBytes;
+    }
+    toString() {
+        return bytesToString(this.toBytes());
+    }
+    get type() {
+        return this.constructor.name;
+    }
+    get byteLength() {
+        return this.toBytes().length;
+    }
+    equals(other) {
+        if (this.byteLength !== other.byteLength) {
+            return false;
+        }
+        const bytes = this.toBytes();
+        const otherBytes = other.toBytes();
+        for (let i = 0; i < this.byteLength; i++) {
+            if (bytes[i] !== otherBytes[i]) {
+                return false;
+            }
+        }
+        return true;
+    }
+}

package/dist/core/tokens/trailer-token.d.ts

@@ -0,0 +1,5 @@
+import { PdfToken } from './token';
+export declare class PdfTrailerToken extends PdfToken {
+    byteOffset?: number;
+    constructor(byteOffset?: number);
+}

package/dist/core/tokens/trailer-token.js

@@ -0,0 +1,10 @@
+import { stringToBytes } from '../../utils/stringToBytes';
+import { PdfToken } from './token';
+const TRAILER = stringToBytes('trailer');
+export class PdfTrailerToken extends PdfToken {
+    byteOffset;
+    constructor(byteOffset) {
+        super(TRAILER);
+        this.byteOffset = byteOffset;
+    }
+}

package/dist/core/tokens/whitespace-token.d.ts

@@ -0,0 +1,11 @@
+import { ByteArray } from '../../types';
+import { PdfToken } from './token';
+export declare class PdfWhitespaceToken extends PdfToken {
+    static NEWLINE: PdfWhitespaceToken;
+    static SPACE: PdfWhitespaceToken;
+    static TAB: PdfWhitespaceToken;
+    static CARRIAGE_RETURN: PdfWhitespaceToken;
+    constructor(value: string | ByteArray | number);
+    private static toBytes;
+    static isWhitespaceByte(byte: number | null | undefined): boolean;
+}

package/dist/core/tokens/whitespace-token.js

@@ -0,0 +1,36 @@
+import { PdfToken } from './token';
+export class PdfWhitespaceToken extends PdfToken {
+    static NEWLINE = new PdfWhitespaceToken('\n');
+    static SPACE = new PdfWhitespaceToken(' ');
+    static TAB = new PdfWhitespaceToken('\t');
+    static CARRIAGE_RETURN = new PdfWhitespaceToken('\r');
+    constructor(value) {
+        super(PdfWhitespaceToken.toBytes(value));
+    }
+    static toBytes(value) {
+        if (value instanceof Uint8Array) {
+            return value;
+        }
+        if (typeof value === 'number') {
+            return new Uint8Array([value]);
+        }
+        switch (value) {
+            case ' ':
+                return new Uint8Array([0x20]); // space character
+            case '\t':
+                return new Uint8Array([0x09]); // tab character
+            case '\n':
+                return new Uint8Array([0x0a]); // newline character
+            case '\r':
+                return new Uint8Array([0x0d]); // carriage return character
+            default:
+                throw new Error(`Invalid whitespace character: ${value}`);
+        }
+    }
+    static isWhitespaceByte(byte) {
+        if (byte === null || byte === undefined) {
+            return false;
+        }
+        return byte === 0x20 || byte === 0x0a || byte === 0x0d || byte === 0x09;
+    }
+}

package/dist/core/tokens/xref-table-entry-token.d.ts

@@ -0,0 +1,13 @@
+import { ByteArray } from '../../types';
+import { Ref } from '../ref';
+import { PdfNumberToken } from './number-token';
+import { PdfToken } from './token.js';
+export declare class PdfXRefTableEntryToken extends PdfToken {
+    objectNumber: PdfNumberToken;
+    generationNumber: PdfNumberToken;
+    offset: PdfNumberToken;
+    inUse: boolean;
+    constructor(offset: number | Ref<number> | PdfNumberToken, generationNumber: number | PdfNumberToken, objectNumber: number | PdfNumberToken, inUse: boolean);
+    toBytes(): ByteArray;
+    private static toBytes;
+}