@syncfusion/ej2-pdf 1.0.23 → 23.1.38

package/src/pdf/core/pdf-primitives.d.ts

@@ -0,0 +1,87 @@
+import { _PdfCrossReference } from './pdf-cross-reference';
+export declare class _PdfName {
+    constructor(name: string);
+    name: string;
+    static get(name: string): _PdfName;
+}
+export declare class _PdfCommand {
+    constructor(command: string);
+    command: string;
+    static get(command: string): _PdfCommand;
+}
+export declare class _PdfReference {
+    constructor(objectNumber: number, gen: number);
+    objectNumber: number;
+    generationNumber: number;
+    _isNew: boolean;
+    toString(): string;
+    static get(objectNumber: number, generationNumber: number): _PdfReference;
+}
+export declare class _PdfReferenceSet {
+    constructor(parent?: any);
+    _set: Set<_PdfReference>;
+    has(ref: any): boolean;
+    put(ref: any): void;
+    remove(ref: any): void;
+    clear(): void;
+}
+export declare class _PdfReferenceSetCache {
+    constructor();
+    _map: any;
+    readonly size: number;
+    get(ref: _PdfReference): any;
+    has(ref: _PdfReference): boolean;
+    put(ref: _PdfReference, obj: any): void;
+    set(objId: string, obj: any): void;
+    clear(): void;
+}
+export interface IDictionaryPair<K, V> {
+    key: K;
+    value: V;
+}
+export declare class Dictionary<K, V> {
+    protected table: {
+        [key: string]: IDictionaryPair<K, V>;
+    };
+    protected nElements: number;
+    protected toStr: (key: K) => string;
+    constructor(toStringFunction?: (key: K) => string);
+    getValue(key: K): V;
+    setValue(key: K, value: V): V;
+    keys(): K[];
+    containsKey(key: K): boolean;
+    _size(): number;
+}
+export declare class _PdfDictionary {
+    constructor(xref?: _PdfCrossReference);
+    _map: any;
+    _crossReference: _PdfCrossReference;
+    objId: any;
+    _isNew: boolean;
+    suppressEncryption: boolean;
+    _updated: boolean;
+    isCatalog: boolean;
+    _currentObj: any;
+    _isFont: boolean;
+    readonly size: number;
+    assignXref(xref: any): void;
+    getRaw(key: string): any;
+    getRawValues(): any;
+    get(key1: string, key2?: string, key3?: string): any;
+    getArray(key1: string, key2?: string, key3?: string): any;
+    set(key: string, value: any): void;
+    has(key: string): boolean;
+    forEach(callback: any): void;
+    update(key: string, value: any): void;
+    static getEmpty(xref: _PdfCrossReference): _PdfDictionary;
+    static merge(xref: _PdfCrossReference, dictionaryArray: Array<any>, mergeSubDictionary?: boolean): _PdfDictionary;
+    _initialize(xref?: _PdfCrossReference): void;
+    _get(key1: string, key2?: string, key3?: string): any;
+}
+export declare class _PdfNull {
+    constructor(value?: any);
+    value: any;
+}
+export declare function _clearPrimitiveCaches(): void;
+export declare function _isName(value: _PdfName, name: string): boolean;
+export declare function _isCommand(value: _PdfCommand, command: string): boolean;

package/src/pdf/core/pdf-primitives.js

@@ -0,0 +1,305 @@
+import { _defaultToString } from './utils';
+/* eslint-disable */
+var nameCache = Object.create(null);
+var cmdCache = Object.create(null);
+var refCache = Object.create(null);
+var _PdfName = /** @class */ (function () {
+    function _PdfName(name) {
+        this.name = name;
+    }
+    _PdfName.get = function (name) {
+        return nameCache[name] || (nameCache[name] = new _PdfName(name));
+    };
+    return _PdfName;
+}());
+export { _PdfName };
+var _PdfCommand = /** @class */ (function () {
+    function _PdfCommand(command) {
+        this.command = command;
+    }
+    _PdfCommand.get = function (command) {
+        return cmdCache[command] || (cmdCache[command] = new _PdfCommand(command));
+    };
+    return _PdfCommand;
+}());
+export { _PdfCommand };
+var _PdfReference = /** @class */ (function () {
+    function _PdfReference(objectNumber, gen) {
+        this._isNew = false;
+        this.objectNumber = objectNumber;
+        this.generationNumber = gen;
+    }
+    _PdfReference.prototype.toString = function () {
+        return this.objectNumber + " " + this.generationNumber;
+    };
+    _PdfReference.get = function (objectNumber, generationNumber) {
+        var key = generationNumber === 0 ? objectNumber + "R" : objectNumber + "R" + generationNumber;
+        return refCache[key] || (refCache[key] = new _PdfReference(objectNumber, generationNumber));
+    };
+    return _PdfReference;
+}());
+export { _PdfReference };
+var _PdfReferenceSet = /** @class */ (function () {
+    function _PdfReferenceSet(parent) {
+        if (parent === void 0) { parent = null; }
+        this._set = new Set(parent && parent._set);
+    }
+    _PdfReferenceSet.prototype.has = function (ref) {
+        return this._set.has(ref.toString());
+    };
+    _PdfReferenceSet.prototype.put = function (ref) {
+        this._set.add(ref.toString());
+    };
+    _PdfReferenceSet.prototype.remove = function (ref) {
+        this._set.delete(ref.toString());
+    };
+    _PdfReferenceSet.prototype.clear = function () {
+        this._set.clear();
+    };
+    return _PdfReferenceSet;
+}());
+export { _PdfReferenceSet };
+var _PdfReferenceSetCache = /** @class */ (function () {
+    function _PdfReferenceSetCache() {
+        this._map = new Map();
+    }
+    Object.defineProperty(_PdfReferenceSetCache.prototype, "size", {
+        get: function () {
+            return this._map.size;
+        },
+        enumerable: true,
+        configurable: true
+    });
+    _PdfReferenceSetCache.prototype.get = function (ref) {
+        return this._map.get(ref.toString());
+    };
+    _PdfReferenceSetCache.prototype.has = function (ref) {
+        return this._map.has(ref.toString());
+    };
+    _PdfReferenceSetCache.prototype.put = function (ref, obj) {
+        this._map.set(ref.toString(), obj);
+    };
+    _PdfReferenceSetCache.prototype.set = function (objId, obj) {
+        this._map.set(objId, obj);
+    };
+    _PdfReferenceSetCache.prototype.clear = function () {
+        this._map.clear();
+    };
+    return _PdfReferenceSetCache;
+}());
+export { _PdfReferenceSetCache };
+var Dictionary = /** @class */ (function () {
+    function Dictionary(toStringFunction) {
+        this.table = {};
+        this.nElements = 0;
+        this.toStr = toStringFunction || _defaultToString;
+    }
+    Dictionary.prototype.getValue = function (key) {
+        var pair = this.table['$' + this.toStr(key)];
+        if (typeof pair === 'undefined') {
+            return undefined;
+        }
+        return pair.value;
+    };
+    Dictionary.prototype.setValue = function (key, value) {
+        var ret;
+        var k = '$' + this.toStr(key);
+        var previousElement = this.table[k];
+        this.nElements++;
+        ret = undefined;
+        this.table[k] = {
+            key: key,
+            value: value
+        };
+        return ret;
+    };
+    Dictionary.prototype.keys = function () {
+        var keysArray = [];
+        var namesOfKeys = Object.keys(this.table);
+        for (var index1 = 0; index1 < namesOfKeys.length; index1++) {
+            var pair1 = this.table[namesOfKeys[index1]];
+            keysArray.push(pair1.key);
+        }
+        return keysArray;
+    };
+    Dictionary.prototype.containsKey = function (key) {
+        var retutnValue = true;
+        if (typeof this.getValue(key) === 'undefined') {
+            retutnValue = true;
+        }
+        else {
+            retutnValue = false;
+        }
+        return !retutnValue;
+    };
+    Dictionary.prototype._size = function () {
+        return this.nElements;
+    };
+    return Dictionary;
+}());
+export { Dictionary };
+var _PdfDictionary = /** @class */ (function () {
+    function _PdfDictionary(xref) {
+        this._isFont = false;
+        this._initialize(xref);
+    }
+    Object.defineProperty(_PdfDictionary.prototype, "size", {
+        get: function () {
+            return Object.keys(this._map).length;
+        },
+        enumerable: true,
+        configurable: true
+    });
+    _PdfDictionary.prototype.assignXref = function (xref) {
+        this._crossReference = xref;
+    };
+    _PdfDictionary.prototype.getRaw = function (key) {
+        return this._map[key];
+    };
+    _PdfDictionary.prototype.getRawValues = function () {
+        return this._map.values;
+    };
+    _PdfDictionary.prototype.get = function (key1, key2, key3) {
+        var value = this._get(key1, key2, key3);
+        if (this._crossReference && typeof value !== 'undefined' && value instanceof _PdfReference) {
+            value = this._crossReference._fetch(value);
+        }
+        return value;
+    };
+    _PdfDictionary.prototype.getArray = function (key1, key2, key3) {
+        var value = this.get(key1, key2, key3);
+        if (this._crossReference && typeof value !== 'undefined' && Array.isArray(value)) {
+            value = value.slice();
+            for (var i = 0; i < value.length; i++) {
+                var reference = value[Number.parseInt(i.toString(), 10)];
+                if (reference !== null && typeof reference !== 'undefined' && reference instanceof _PdfReference) {
+                    value[Number.parseInt(i.toString(), 10)] = this._crossReference._fetch(reference);
+                }
+            }
+        }
+        return value;
+    };
+    _PdfDictionary.prototype.set = function (key, value) {
+        this._map[key] = value;
+    };
+    _PdfDictionary.prototype.has = function (key) {
+        return typeof this._map[key] !== 'undefined';
+    };
+    _PdfDictionary.prototype.forEach = function (callback) {
+        for (var key in this._map) {
+            callback(key, this.getRaw(key));
+        }
+    };
+    _PdfDictionary.prototype.update = function (key, value) {
+        if (this.has(key)) {
+            var prevValue = this._map[key];
+            if (prevValue !== null && typeof prevValue !== 'undefined' && prevValue instanceof _PdfReference && this._crossReference) {
+                prevValue = this._crossReference._fetch(prevValue);
+            }
+            if (prevValue !== value) {
+                this._map[key] = value;
+                this._updated = true;
+            }
+        }
+        else {
+            this._map[key] = value;
+            this._updated = true;
+        }
+    };
+    _PdfDictionary.getEmpty = function (xref) {
+        var emptyDict = new _PdfDictionary(xref);
+        emptyDict.set = function (key, value) {
+            throw new Error('Should not call set on the empty dictionary.');
+        };
+        return emptyDict;
+    };
+    _PdfDictionary.merge = function (xref, dictionaryArray, mergeSubDictionary) {
+        if (mergeSubDictionary === void 0) { mergeSubDictionary = false; }
+        var mergedDictionary = new _PdfDictionary(xref);
+        var properties = Object.create(null);
+        for (var _i = 0, dictionaryArray_1 = dictionaryArray; _i < dictionaryArray_1.length; _i++) {
+            var dictionary = dictionaryArray_1[_i];
+            if (!(dictionary instanceof _PdfDictionary)) {
+                continue;
+            }
+            for (var _a = 0, _b = dictionary._map; _a < _b.length; _a++) {
+                var _c = _b[_a], key = _c[0], value = _c[1];
+                var property = properties.get(key);
+                if (typeof property === 'undefined') {
+                    property = [];
+                    properties.set(key, property);
+                }
+                else if (!mergeSubDictionary || !(value instanceof _PdfDictionary)) {
+                    continue;
+                }
+                property.push(value);
+            }
+        }
+        for (var _d = 0, properties_1 = properties; _d < properties_1.length; _d++) {
+            var _e = properties_1[_d], name_1 = _e[0], values = _e[1];
+            if (values.length === 1 || !(values[0] instanceof _PdfDictionary)) {
+                mergedDictionary._map[name_1] = values[0];
+                continue;
+            }
+            var subDict = new _PdfDictionary(xref);
+            for (var _f = 0, values_1 = values; _f < values_1.length; _f++) {
+                var dictionary = values_1[_f];
+                for (var _g = 0, _h = dictionary._map; _g < _h.length; _g++) {
+                    var _j = _h[_g], key = _j[0], value = _j[1];
+                    if (typeof subDict._map[key] === 'undefined') {
+                        subDict._map[key] = value;
+                    }
+                }
+            }
+            if (subDict.size > 0) {
+                mergedDictionary._map[name_1] = subDict;
+            }
+        }
+        properties.clear();
+        return mergedDictionary.size > 0 ? mergedDictionary : _PdfDictionary.getEmpty(xref);
+    };
+    _PdfDictionary.prototype._initialize = function (xref) {
+        this._map = Object.create(null);
+        this.suppressEncryption = false;
+        this._updated = false;
+        this.isCatalog = false;
+        this._isNew = false;
+        if (xref) {
+            this._crossReference = xref;
+        }
+    };
+    _PdfDictionary.prototype._get = function (key1, key2, key3) {
+        var value = this._map[key1];
+        if (typeof value === 'undefined') {
+            value = this._map[key2];
+            if (typeof key2 !== 'undefined' && key2 !== null) {
+                value = this._map[key2];
+            }
+            else if (typeof key3 !== 'undefined' && key3 !== null) {
+                value = this._map[key3];
+            }
+        }
+        return value;
+    };
+    return _PdfDictionary;
+}());
+export { _PdfDictionary };
+var _PdfNull = /** @class */ (function () {
+    function _PdfNull(value) {
+        if (value === void 0) { value = []; }
+        this.value = value;
+    }
+    return _PdfNull;
+}());
+export { _PdfNull };
+export function _clearPrimitiveCaches() {
+    nameCache = Object.create(null);
+    cmdCache = Object.create(null);
+    refCache = Object.create(null);
+}
+export function _isName(value, name) {
+    return value instanceof _PdfName && (typeof name === 'undefined' || value.name === name);
+}
+export function _isCommand(value, command) {
+    return value instanceof _PdfCommand && (typeof command === 'undefined' || value.command === command);
+}

package/src/pdf/core/predictor-stream.d.ts

@@ -0,0 +1,15 @@
+import { _PdfDecodeStream } from './decode-stream';
+import { _PdfDictionary } from './pdf-primitives';
+export declare class PdfPredictorStream extends _PdfDecodeStream {
+    predictor: number;
+    dictionary: _PdfDictionary;
+    pixBytes: number;
+    rowBytes: number;
+    colors: number;
+    bits: number;
+    columns: number;
+    readBlock: any;
+    constructor(stream: any, maybeLength: number, params: _PdfDictionary);
+    readBlockTiff(): void;
+    readBlockPng(): void;
+}

package/src/pdf/core/predictor-stream.js

@@ -0,0 +1,214 @@
+var __extends = (this && this.__extends) || (function () {
+    var extendStatics = function (d, b) {
+        extendStatics = Object.setPrototypeOf ||
+            ({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) ||
+            function (d, b) { for (var p in b) if (b.hasOwnProperty(p)) d[p] = b[p]; };
+        return extendStatics(d, b);
+    };
+    return function (d, b) {
+        extendStatics(d, b);
+        function __() { this.constructor = d; }
+        d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
+    };
+})();
+import { _PdfDecodeStream } from './decode-stream';
+import { _PdfDictionary } from './pdf-primitives';
+import { FormatError } from './utils';
+var PdfPredictorStream = /** @class */ (function (_super) {
+    __extends(PdfPredictorStream, _super);
+    function PdfPredictorStream(stream, maybeLength, params) {
+        var _this = _super.call(this, maybeLength) || this;
+        if (!(params instanceof _PdfDictionary)) {
+            return stream;
+        }
+        var predictor = (_this.predictor = params.get('Predictor') || 1);
+        if (predictor <= 1) {
+            return stream;
+        }
+        if (predictor !== 2 && (predictor < 10 || predictor > 15)) {
+            throw new FormatError("Unsupported predictor: " + predictor);
+        }
+        if (predictor === 2) {
+            _this.readBlock = _this.readBlockTiff;
+        }
+        else {
+            _this.readBlock = _this.readBlockPng;
+        }
+        _this.stream = stream;
+        _this.dictionary = stream.dictionary;
+        var colors = (_this.colors = params.get('Colors') || 1);
+        var bits = (_this.bits = params.get('BPC', 'BitsPerComponent') || 8);
+        var columns = (_this.columns = params.get('Columns') || 1);
+        _this.pixBytes = (colors * bits + 7) >> 3;
+        _this.rowBytes = (columns * colors * bits + 7) >> 3;
+        return _this;
+    }
+    PdfPredictorStream.prototype.readBlockTiff = function () {
+        var rowBytes = this.rowBytes;
+        var bufferLength = this.bufferLength;
+        var buffer = this.ensureBuffer(bufferLength + rowBytes);
+        var bits = this.bits;
+        var colors = this.colors;
+        var rawBytes = this.stream.getBytes(rowBytes);
+        this.eof = !rawBytes.length;
+        if (this.eof) {
+            return;
+        }
+        var inbuf = 0;
+        var outbuf = 0;
+        var inbits = 0;
+        var outbits = 0;
+        var position = bufferLength;
+        var i;
+        if (bits === 1 && colors === 1) {
+            for (i = 0; i < rowBytes; ++i) {
+                var c = rawBytes[i] ^ inbuf; // eslint-disable-line
+                c ^= c >> 1;
+                c ^= c >> 2;
+                c ^= c >> 4;
+                inbuf = (c & 1) << 7;
+                buffer[position++] = c;
+            }
+        }
+        else if (bits === 8) {
+            for (i = 0; i < colors; ++i) {
+                buffer[position++] = rawBytes[i]; // eslint-disable-line
+            }
+            for (; i < rowBytes; ++i) {
+                buffer[position] = buffer[position - colors] + rawBytes[i]; // eslint-disable-line
+                position++;
+            }
+        }
+        else if (bits === 16) {
+            var bytesPerPixel = colors * 2;
+            for (i = 0; i < bytesPerPixel; ++i) {
+                buffer[position++] = rawBytes[i]; // eslint-disable-line
+            }
+            for (; i < rowBytes; i += 2) {
+                var sum = ((rawBytes[i] & 0xff) << 8) + // eslint-disable-line
+                    (rawBytes[i + 1] & 0xff) +
+                    ((buffer[position - bytesPerPixel] & 0xff) << 8) +
+                    (buffer[position - bytesPerPixel + 1] & 0xff);
+                buffer[position++] = (sum >> 8) & 0xff;
+                buffer[position++] = sum & 0xff;
+            }
+        }
+        else {
+            var compArray = new Uint8Array(colors + 1);
+            var bitMask = (1 << bits) - 1;
+            var j = 0;
+            var k = bufferLength;
+            var columns = this.columns;
+            for (i = 0; i < columns; ++i) {
+                for (var kk = 0; kk < colors; ++kk) {
+                    if (inbits < bits) {
+                        inbuf = (inbuf << 8) | (rawBytes[j++] & 0xff);
+                        inbits += 8;
+                    }
+                    compArray[kk] = (compArray[kk] + (inbuf >> (inbits - bits))) & bitMask; // eslint-disable-line
+                    inbits -= bits;
+                    outbuf = (outbuf << bits) | compArray[kk]; // eslint-disable-line
+                    outbits += bits;
+                    if (outbits >= 8) {
+                        buffer[k++] = (outbuf >> (outbits - 8)) & 0xff;
+                        outbits -= 8;
+                    }
+                }
+            }
+            if (outbits > 0) {
+                buffer[k++] = (outbuf << (8 - outbits)) + (inbuf & ((1 << (8 - outbits)) - 1));
+            }
+        }
+        this.bufferLength += rowBytes;
+    };
+    PdfPredictorStream.prototype.readBlockPng = function () {
+        var rowBytes = this.rowBytes;
+        var pixBytes = this.pixBytes;
+        var predictor = this.stream.getByte();
+        var rawBytes = this.stream.getBytes(rowBytes);
+        this.eof = !rawBytes.length;
+        if (this.eof) {
+            return;
+        }
+        var bufferLength = this.bufferLength;
+        var buffer = this.ensureBuffer(bufferLength + rowBytes);
+        var prevRow = buffer.subarray(bufferLength - rowBytes, bufferLength);
+        if (prevRow.length === 0) {
+            prevRow = new Uint8Array(rowBytes);
+        }
+        var i;
+        var j = bufferLength;
+        var up;
+        var c;
+        switch (predictor) {
+            case 0:
+                for (i = 0; i < rowBytes; ++i) {
+                    buffer[j++] = rawBytes[i]; // eslint-disable-line
+                }
+                break;
+            case 1:
+                for (i = 0; i < pixBytes; ++i) {
+                    buffer[j++] = rawBytes[i]; // eslint-disable-line
+                }
+                for (; i < rowBytes; ++i) {
+                    buffer[j] = (buffer[j - pixBytes] + rawBytes[i]) & 0xff; // eslint-disable-line
+                    j++;
+                }
+                break;
+            case 2:
+                for (i = 0; i < rowBytes; ++i) {
+                    buffer[j++] = (prevRow[i] + rawBytes[i]) & 0xff; // eslint-disable-line
+                }
+                break;
+            case 3:
+                for (i = 0; i < pixBytes; ++i) {
+                    buffer[j++] = (prevRow[i] >> 1) + rawBytes[i]; // eslint-disable-line
+                }
+                for (; i < rowBytes; ++i) {
+                    buffer[j] = (((prevRow[i] + buffer[j - pixBytes]) >> 1) + rawBytes[i]) & 0xff; // eslint-disable-line
+                    j++;
+                }
+                break;
+            case 4:
+                for (i = 0; i < pixBytes; ++i) {
+                    up = prevRow[i]; // eslint-disable-line
+                    c = rawBytes[i]; // eslint-disable-line
+                    buffer[j++] = up + c;
+                }
+                for (; i < rowBytes; ++i) {
+                    up = prevRow[i]; // eslint-disable-line
+                    var upLeft = prevRow[i - pixBytes];
+                    var left = buffer[j - pixBytes];
+                    var p = left + up - upLeft;
+                    var pa = p - left;
+                    if (pa < 0) {
+                        pa = -pa;
+                    }
+                    var pb = p - up;
+                    if (pb < 0) {
+                        pb = -pb;
+                    }
+                    var pc = p - upLeft;
+                    if (pc < 0) {
+                        pc = -pc;
+                    }
+                    c = rawBytes[i]; // eslint-disable-line
+                    if (pa <= pb && pa <= pc) {
+                        buffer[j++] = left + c;
+                    }
+                    else if (pb <= pc) {
+                        buffer[j++] = up + c;
+                    }
+                    else {
+                        buffer[j++] = upLeft + c;
+                    }
+                }
+                break;
+            default:
+                throw new FormatError("Unsupported predictor: " + predictor);
+        }
+        this.bufferLength += rowBytes;
+    };
+    return PdfPredictorStream;
+}(_PdfDecodeStream));
+export { PdfPredictorStream };