@syncfusion/ej2-pdf 1.0.23 → 23.1.36

package/src/pdf/core/content-parser.d.ts

@@ -0,0 +1,38 @@
+import { _TokenType } from './enumerator';
+export declare class _ContentParser {
+    _lexer: _ContentLexer;
+    _recordCollection: _PdfRecord[];
+    _operands: string[];
+    constructor(contentStream: number[]);
+    constructor(contentStream: Uint8Array);
+    _readContent(): _PdfRecord[];
+    _parseObject(tokenType: _TokenType): void;
+    _createRecord(): void;
+    _getNextToken(): _TokenType;
+}
+export declare class _ContentLexer {
+    _data: Uint8Array;
+    _tokenType: _TokenType;
+    _operatorParams: string;
+    _currentCharacter: string;
+    _nextCharacter: string;
+    _offset: number;
+    constructor(data: Uint8Array | number[]);
+    _getNextToken(): _TokenType;
+    _getComment(): _TokenType;
+    _getName(): _TokenType;
+    _getNumber(): _TokenType;
+    _getOperator(): _TokenType;
+    _isOperator(value: string): boolean;
+    _getLiteralString(): _TokenType;
+    _getEncodedDecimalString(): _TokenType;
+    _getLiteralStringValue(value: string): string;
+    _consumeValue(): string;
+    _moveToNextChar(): string;
+    _getNextChar(): string;
+}
+export declare class _PdfRecord {
+    _operator: string;
+    _operands: string[];
+    constructor(operator: string, operands: string[]);
+}

package/src/pdf/core/content-parser.js

@@ -0,0 +1,359 @@
+import { _TokenType } from './enumerator';
+var _ContentParser = /** @class */ (function () {
+    function _ContentParser(contentStream) {
+        this._recordCollection = [];
+        this._operands = [];
+        this._lexer = new _ContentLexer(contentStream);
+    }
+    _ContentParser.prototype._readContent = function () {
+        this._parseObject(_TokenType.eof);
+        return this._recordCollection;
+    };
+    _ContentParser.prototype._parseObject = function (tokenType) {
+        var symbol;
+        while ((symbol = this._getNextToken()) !== _TokenType.eof) { // eslint-disable-line
+            if (symbol === tokenType || symbol === _TokenType.none) {
+                return;
+            }
+            switch (symbol) {
+                case _TokenType.comment:
+                    break;
+                case _TokenType.number:
+                    if (this._lexer._operatorParams === '-') {
+                        this._operands.push('0');
+                    }
+                    else {
+                        this._operands.push(this._lexer._operatorParams);
+                    }
+                    break;
+                case _TokenType.real:
+                    this._operands.push(this._lexer._operatorParams);
+                    break;
+                case _TokenType.string:
+                case _TokenType.hexString:
+                case _TokenType.unicodeHexString:
+                case _TokenType.unicodeString:
+                    this._operands.push(this._lexer._operatorParams);
+                    break;
+                case _TokenType.name:
+                    this._operands.push(this._lexer._operatorParams);
+                    break;
+                case _TokenType.operator:
+                    this._createRecord();
+                    this._operands = [];
+                    break;
+                case _TokenType.beginArray:
+                    break;
+                case _TokenType.endArray:
+                    throw new Error('Error while parsing content');
+            }
+        }
+    };
+    _ContentParser.prototype._createRecord = function () {
+        var operand = this._lexer._operatorParams;
+        var record = new _PdfRecord(operand, this._operands);
+        this._recordCollection.push(record);
+    };
+    _ContentParser.prototype._getNextToken = function () {
+        return this._lexer._getNextToken();
+    };
+    return _ContentParser;
+}());
+export { _ContentParser };
+var _ContentLexer = /** @class */ (function () {
+    function _ContentLexer(data) {
+        this._tokenType = _TokenType.none;
+        this._currentCharacter = '\0';
+        this._nextCharacter = '\0';
+        this._offset = 0;
+        this._data = data instanceof Uint8Array ? data : new Uint8Array(data);
+    }
+    _ContentLexer.prototype._getNextToken = function () {
+        this._operatorParams = '';
+        var value = this._moveToNextChar();
+        switch (value) {
+            case '%':
+                return this._tokenType = this._getComment();
+            case '/':
+                return this._tokenType = this._getName();
+            case '[':
+            case '(':
+                return this._tokenType = this._getLiteralString();
+            case '+':
+            case '-':
+                return this._tokenType = this._getNumber();
+            case '<':
+                return this._tokenType = this._getEncodedDecimalString();
+            case '.':
+                return this._tokenType = this._getNumber();
+            case '"':
+            case '\'':
+                return this._tokenType = this._getOperator();
+        }
+        if (!isNaN(parseInt(value, 10))) {
+            return this._tokenType = this._getNumber();
+        }
+        if ((/[a-zA-Z]/).test(value)) {
+            return this._tokenType = this._getOperator();
+        }
+        if (value === String.fromCharCode(65535)) {
+            return this._tokenType = _TokenType.eof;
+        }
+        return this._tokenType = _TokenType.none;
+    };
+    _ContentLexer.prototype._getComment = function () {
+        this._operatorParams = '';
+        var value;
+        var flag = (value = this._consumeValue()) !== '\x0A' && value !== String.fromCharCode(65535);
+        while (flag) {
+            flag = (value = this._consumeValue()) !== '\x0A' && value !== String.fromCharCode(65535);
+        }
+        return _TokenType.comment;
+    };
+    _ContentLexer.prototype._getName = function () {
+        this._operatorParams = '';
+        var flag = false;
+        while (!flag) {
+            var value = this._consumeValue();
+            switch (value) {
+                case '\0':
+                case '\t':
+                case '\x0A':
+                case '\f':
+                case '\x0D':
+                case '\b':
+                case ' ':
+                case '%':
+                case '(':
+                case ')':
+                case '<':
+                case '>':
+                case '[':
+                case ']':
+                case '/':
+                    flag = true;
+                    return _TokenType.name;
+                default:
+                    break;
+            }
+        }
+        return _TokenType.none;
+    };
+    _ContentLexer.prototype._getNumber = function () {
+        var value = this._currentCharacter;
+        if (value === '+' || value === '-') {
+            this._operatorParams += this._currentCharacter;
+            value = this._getNextChar();
+        }
+        while (!isNaN(parseInt(value, 10)) || value === '.') {
+            if (!isNaN(parseInt(value, 10))) {
+                this._operatorParams += this._currentCharacter;
+            }
+            else if (value === '.') {
+                if (this._operatorParams.includes('.')) {
+                    break;
+                }
+                else {
+                    this._operatorParams += this._currentCharacter;
+                }
+            }
+            value = this._getNextChar();
+        }
+        return _TokenType.number;
+    };
+    _ContentLexer.prototype._getOperator = function () {
+        this._operatorParams = '';
+        var value = this._currentCharacter;
+        while (this._isOperator(value)) {
+            value = this._consumeValue();
+        }
+        return _TokenType.operator;
+    };
+    _ContentLexer.prototype._isOperator = function (value) {
+        if ((/[a-zA-Z]/).test(value)) {
+            return true;
+        }
+        switch (value) {
+            case '*':
+            case '\'':
+            case '\"': // eslint-disable-line
+            case '1':
+            case '0':
+                return true;
+        }
+        return false;
+    };
+    _ContentLexer.prototype._getLiteralString = function () {
+        this._operatorParams = '';
+        var beginChar = this._currentCharacter;
+        var literal;
+        var value = this._consumeValue();
+        var flag = true;
+        while (flag) {
+            if (beginChar === '(') {
+                literal = this._getLiteralStringValue(value);
+                this._operatorParams += literal;
+                value = this._getNextChar();
+                flag = false;
+                break;
+            }
+            else {
+                if (value === '(') {
+                    value = this._consumeValue();
+                    literal = this._getLiteralStringValue(value);
+                    this._operatorParams += literal;
+                    value = this._getNextChar();
+                    continue;
+                }
+                else if (value === ']') {
+                    flag = false;
+                    value = this._consumeValue();
+                    break;
+                }
+                value = this._consumeValue();
+            }
+        }
+        return _TokenType.string;
+    };
+    _ContentLexer.prototype._getEncodedDecimalString = function () {
+        var startChar = '<';
+        var endChar = '>';
+        var space = ' ';
+        var parentLevel = 0;
+        var value = this._consumeValue();
+        var flag = true;
+        while (flag) {
+            if (value === startChar) {
+                parentLevel++;
+                value = this._consumeValue();
+            }
+            else if (value === endChar) {
+                if (parentLevel === 0) {
+                    this._consumeValue();
+                    flag = false;
+                    break;
+                }
+                else if (parentLevel === 1) {
+                    value = this._consumeValue();
+                    if (value === '>') {
+                        parentLevel--;
+                    }
+                    if (parentLevel === 1 && value === space) {
+                        flag = false;
+                        break;
+                    }
+                }
+                else {
+                    if (value === '>') {
+                        parentLevel--;
+                    }
+                    value = this._consumeValue();
+                }
+            }
+            else {
+                value = this._consumeValue();
+                if (value === String.fromCharCode(65535)) {
+                    flag = false;
+                    break;
+                }
+            }
+        }
+        return _TokenType.hexString;
+    };
+    _ContentLexer.prototype._getLiteralStringValue = function (value) {
+        var parenthesesCount = 0;
+        var literal = '';
+        var flag = true;
+        while (flag) {
+            if (value === '\\') {
+                literal += value;
+                value = this._getNextChar();
+                literal += value;
+                value = this._getNextChar();
+                continue;
+            }
+            if (value === '(') {
+                parenthesesCount++;
+                literal += value;
+                value = this._getNextChar();
+                continue;
+            }
+            if (value === ')' && parenthesesCount !== 0) {
+                literal += value;
+                value = this._getNextChar();
+                parenthesesCount--;
+                continue;
+            }
+            if (value === ')' && parenthesesCount === 0) {
+                literal += value;
+                flag = false;
+                return literal;
+            }
+            literal += value;
+            value = this._getNextChar();
+        }
+        return literal;
+    };
+    _ContentLexer.prototype._consumeValue = function () {
+        this._operatorParams += this._currentCharacter;
+        return this._getNextChar();
+    };
+    _ContentLexer.prototype._moveToNextChar = function () {
+        while (this._currentCharacter !== String.fromCharCode(65535)) {
+            switch (this._currentCharacter) {
+                case '\0':
+                case '\t':
+                case '\x0A':
+                case '\f':
+                case '\x0D':
+                case '\b':
+                case ' ':
+                    this._getNextChar();
+                    break;
+                default:
+                    return this._currentCharacter;
+            }
+        }
+        return this._currentCharacter;
+    };
+    _ContentLexer.prototype._getNextChar = function () {
+        if (this._data.length <= this._offset) {
+            if (this._nextCharacter === 'Q' || (this._currentCharacter === 'D' && this._nextCharacter === 'o')) {
+                this._currentCharacter = this._nextCharacter;
+                this._nextCharacter = String.fromCharCode(65535);
+                return this._currentCharacter;
+            }
+            this._currentCharacter = String.fromCharCode(65535);
+            this._nextCharacter = String.fromCharCode(65535);
+        }
+        else {
+            this._currentCharacter = this._nextCharacter;
+            this._nextCharacter = String.fromCharCode(this._data[this._offset++]);
+            if (this._currentCharacter === '\x0D') {
+                if (this._nextCharacter === '\x0A') {
+                    this._currentCharacter = this._nextCharacter;
+                    if (this._data.length <= this._offset) {
+                        this._nextCharacter = String.fromCharCode(65535);
+                    }
+                    else {
+                        this._nextCharacter = String.fromCharCode(this._data[this._offset++]);
+                    }
+                }
+                else {
+                    this._currentCharacter = '\x0A';
+                }
+            }
+        }
+        return this._currentCharacter;
+    };
+    return _ContentLexer;
+}());
+export { _ContentLexer };
+var _PdfRecord = /** @class */ (function () {
+    function _PdfRecord(operator, operands) {
+        this._operator = operator;
+        this._operands = operands;
+    }
+    return _PdfRecord;
+}());
+export { _PdfRecord };

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

@@ -0,0 +1,21 @@
+import { _PdfBaseStream } from './base-stream';
+import { _PdfDictionary } from './pdf-primitives';
+export declare class _PdfDecodeStream extends _PdfBaseStream {
+    constructor(maybeMinBufferLength: number);
+    _rawMinBufferLength: number;
+    bufferLength: number;
+    eof: boolean;
+    buffer: Uint8Array;
+    minBufferLength: number;
+    stream: _PdfBaseStream;
+    readonly isEmpty: boolean;
+    ensureBuffer(requested: number): Uint8Array;
+    getByte(): number;
+    getBytes(length: number): Uint8Array;
+    reset(): void;
+    makeSubStream(start: number, length: number, dictionary: _PdfDictionary): _PdfBaseStream;
+    getBaseStreams(): _PdfBaseStream[];
+    moveStart(): void;
+    getByteRange(begin: number, end: number): Uint8Array;
+    readBlock(): void;
+}

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

@@ -0,0 +1,120 @@
+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 { _PdfBaseStream, _PdfStream } from './base-stream';
+var _PdfDecodeStream = /** @class */ (function (_super) {
+    __extends(_PdfDecodeStream, _super);
+    function _PdfDecodeStream(maybeMinBufferLength) {
+        var _this = _super.call(this) || this;
+        _this._rawMinBufferLength = maybeMinBufferLength || 0;
+        _this.offset = 0;
+        _this.bufferLength = 0;
+        _this.eof = false;
+        _this.buffer = new Uint8Array(0);
+        _this.minBufferLength = 512;
+        if (maybeMinBufferLength) {
+            while (_this.minBufferLength < maybeMinBufferLength) {
+                _this.minBufferLength *= 2;
+            }
+        }
+        return _this;
+    }
+    Object.defineProperty(_PdfDecodeStream.prototype, "isEmpty", {
+        get: function () {
+            while (!this.eof && this.bufferLength === 0) {
+                this.readBlock();
+            }
+            return this.bufferLength === 0;
+        },
+        enumerable: true,
+        configurable: true
+    });
+    _PdfDecodeStream.prototype.ensureBuffer = function (requested) {
+        var buffer = this.buffer;
+        if (requested <= buffer.byteLength) {
+            return buffer;
+        }
+        var size = this.minBufferLength;
+        while (size < requested) {
+            size *= 2;
+        }
+        var buffer2 = new Uint8Array(size);
+        buffer2.set(buffer);
+        this.buffer = buffer2;
+        return this.buffer;
+    };
+    _PdfDecodeStream.prototype.getByte = function () {
+        var position = this.offset;
+        while (this.bufferLength <= position) {
+            if (this.eof) {
+                return -1;
+            }
+            this.readBlock();
+        }
+        return this.buffer[this.offset++];
+    };
+    _PdfDecodeStream.prototype.getBytes = function (length) {
+        var position = this.offset;
+        var end;
+        if (length) {
+            this.ensureBuffer(position + length);
+            end = position + length;
+            while (!this.eof && this.bufferLength < end) {
+                this.readBlock();
+            }
+            var bufEnd = this.bufferLength;
+            if (end > bufEnd) {
+                end = bufEnd;
+            }
+        }
+        else {
+            while (!this.eof) {
+                this.readBlock();
+            }
+            end = this.bufferLength;
+        }
+        this.offset = end;
+        return this.buffer.subarray(position, end);
+    };
+    _PdfDecodeStream.prototype.reset = function () {
+        this.offset = 0;
+    };
+    _PdfDecodeStream.prototype.makeSubStream = function (start, length, dictionary) {
+        if (length === undefined) {
+            while (!this.eof) {
+                this.readBlock();
+            }
+        }
+        else {
+            var end = start + length;
+            while (this.bufferLength <= end && !this.eof) {
+                this.readBlock();
+            }
+        }
+        return new _PdfStream(this.buffer, dictionary, start, length);
+    };
+    _PdfDecodeStream.prototype.getBaseStreams = function () {
+        return this.stream ? this.stream.getBaseStreams() : null;
+    };
+    _PdfDecodeStream.prototype.moveStart = function () {
+        throw new Error('Invalid call from decode stream');
+    };
+    _PdfDecodeStream.prototype.getByteRange = function (begin, end) {
+        throw new Error('Invalid call from decode stream. begin: ' + begin + ', end: ' + end);
+    };
+    _PdfDecodeStream.prototype.readBlock = function () {
+        throw new Error('Invalid call from decode stream');
+    };
+    return _PdfDecodeStream;
+}(_PdfBaseStream));
+export { _PdfDecodeStream };

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

@@ -0,0 +1,11 @@
+import { _PdfBaseStream } from './base-stream';
+import { _PdfDecodeStream } from './decode-stream';
+import { _Cipher } from './security/encryptor';
+export declare class _PdfDecryptStream extends _PdfDecodeStream {
+    readonly _chunkSize: number;
+    _initialized: boolean;
+    _nextChunk: Uint8Array;
+    _cipher: _Cipher;
+    constructor(stream: _PdfBaseStream, maybeLength: number, cipher: _Cipher);
+    readBlock(): void;
+}

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

@@ -0,0 +1,53 @@
+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';
+var _PdfDecryptStream = /** @class */ (function (_super) {
+    __extends(_PdfDecryptStream, _super);
+    function _PdfDecryptStream(stream, maybeLength, cipher) {
+        var _this = _super.call(this, maybeLength) || this;
+        _this._chunkSize = 512;
+        _this.stream = stream;
+        _this.dictionary = stream.dictionary;
+        _this._cipher = cipher;
+        _this._nextChunk = null;
+        _this._initialized = false;
+        return _this;
+    }
+    _PdfDecryptStream.prototype.readBlock = function () {
+        var chunk;
+        if (this._initialized) {
+            chunk = this._nextChunk;
+        }
+        else {
+            chunk = this.stream.getBytes(this._chunkSize);
+            this._initialized = true;
+        }
+        if (!chunk || chunk.length === 0) {
+            this.eof = true;
+            return;
+        }
+        this._nextChunk = this.stream.getBytes(this._chunkSize);
+        var hasMoreData = this._nextChunk && this._nextChunk.length > 0;
+        chunk = this._cipher._decryptBlock(chunk, !hasMoreData);
+        var bufferLength = this.bufferLength;
+        var n = chunk.length;
+        var buffer = this.ensureBuffer(bufferLength + n);
+        for (var i = 0; i < n; i++) {
+            buffer[bufferLength++] = chunk[Number.parseInt(i.toString(), 10)];
+        }
+        this.bufferLength = bufferLength;
+    };
+    return _PdfDecryptStream;
+}(_PdfDecodeStream));
+export { _PdfDecryptStream };