art-bd-ui 1.0.21 → 1.0.23

package/dist/cjs/node_modules/pdf-lib/es/core/parser/PDFObjectParser.js

@@ -0,0 +1,241 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+var tslib_es6 = require('../../../../tslib/tslib.es6.js');
+var errors = require('../errors.js');
+var PDFArray = require('../objects/PDFArray.js');
+var PDFBool = require('../objects/PDFBool.js');
+var PDFDict = require('../objects/PDFDict.js');
+var PDFHexString = require('../objects/PDFHexString.js');
+var PDFName = require('../objects/PDFName.js');
+var PDFNull = require('../objects/PDFNull.js');
+var PDFNumber = require('../objects/PDFNumber.js');
+var PDFRawStream = require('../objects/PDFRawStream.js');
+var PDFRef = require('../objects/PDFRef.js');
+var PDFString = require('../objects/PDFString.js');
+var BaseParser = require('./BaseParser.js');
+var ByteStream = require('./ByteStream.js');
+var PDFCatalog = require('../structures/PDFCatalog.js');
+var PDFPageLeaf = require('../structures/PDFPageLeaf.js');
+var PDFPageTree = require('../structures/PDFPageTree.js');
+var CharCodes = require('../syntax/CharCodes.js');
+var Delimiters = require('../syntax/Delimiters.js');
+var Keywords = require('../syntax/Keywords.js');
+var Numeric = require('../syntax/Numeric.js');
+var Whitespace = require('../syntax/Whitespace.js');
+require('../../utils/base64.js');
+var strings = require('../../utils/strings.js');
+require('../../utils/unicode.js');
+require('../../utils/objects.js');
+require('../../utils/pdfDocEncoding.js');
+require('../../utils/Cache.js');
+
+// TODO: Throw error if eof is reached before finishing object parse...
+var PDFObjectParser = /** @class */ (function (_super) {
+    tslib_es6.__extends(PDFObjectParser, _super);
+    function PDFObjectParser(byteStream, context, capNumbers) {
+        if (capNumbers === void 0) { capNumbers = false; }
+        var _this = _super.call(this, byteStream, capNumbers) || this;
+        _this.context = context;
+        return _this;
+    }
+    // TODO: Is it possible to reduce duplicate parsing for ref lookaheads?
+    PDFObjectParser.prototype.parseObject = function () {
+        this.skipWhitespaceAndComments();
+        if (this.matchKeyword(Keywords.Keywords.true))
+            return PDFBool.default.True;
+        if (this.matchKeyword(Keywords.Keywords.false))
+            return PDFBool.default.False;
+        if (this.matchKeyword(Keywords.Keywords.null))
+            return PDFNull.default;
+        var byte = this.bytes.peek();
+        if (byte === CharCodes.default.LessThan &&
+            this.bytes.peekAhead(1) === CharCodes.default.LessThan) {
+            return this.parseDictOrStream();
+        }
+        if (byte === CharCodes.default.LessThan)
+            return this.parseHexString();
+        if (byte === CharCodes.default.LeftParen)
+            return this.parseString();
+        if (byte === CharCodes.default.ForwardSlash)
+            return this.parseName();
+        if (byte === CharCodes.default.LeftSquareBracket)
+            return this.parseArray();
+        if (Numeric.IsNumeric[byte])
+            return this.parseNumberOrRef();
+        throw new errors.PDFObjectParsingError(this.bytes.position(), byte);
+    };
+    PDFObjectParser.prototype.parseNumberOrRef = function () {
+        var firstNum = this.parseRawNumber();
+        this.skipWhitespaceAndComments();
+        var lookaheadStart = this.bytes.offset();
+        if (Numeric.IsDigit[this.bytes.peek()]) {
+            var secondNum = this.parseRawNumber();
+            this.skipWhitespaceAndComments();
+            if (this.bytes.peek() === CharCodes.default.R) {
+                this.bytes.assertNext(CharCodes.default.R);
+                return PDFRef.default.of(firstNum, secondNum);
+            }
+        }
+        this.bytes.moveTo(lookaheadStart);
+        return PDFNumber.default.of(firstNum);
+    };
+    // TODO: Maybe update PDFHexString.of() logic to remove whitespace and validate input?
+    PDFObjectParser.prototype.parseHexString = function () {
+        var value = '';
+        this.bytes.assertNext(CharCodes.default.LessThan);
+        while (!this.bytes.done() && this.bytes.peek() !== CharCodes.default.GreaterThan) {
+            value += strings.charFromCode(this.bytes.next());
+        }
+        this.bytes.assertNext(CharCodes.default.GreaterThan);
+        return PDFHexString.default.of(value);
+    };
+    PDFObjectParser.prototype.parseString = function () {
+        var nestingLvl = 0;
+        var isEscaped = false;
+        var value = '';
+        while (!this.bytes.done()) {
+            var byte = this.bytes.next();
+            value += strings.charFromCode(byte);
+            // Check for unescaped parenthesis
+            if (!isEscaped) {
+                if (byte === CharCodes.default.LeftParen)
+                    nestingLvl += 1;
+                if (byte === CharCodes.default.RightParen)
+                    nestingLvl -= 1;
+            }
+            // Track whether current character is being escaped or not
+            if (byte === CharCodes.default.BackSlash) {
+                isEscaped = !isEscaped;
+            }
+            else if (isEscaped) {
+                isEscaped = false;
+            }
+            // Once (if) the unescaped parenthesis balance out, return their contents
+            if (nestingLvl === 0) {
+                // Remove the outer parens so they aren't part of the contents
+                return PDFString.default.of(value.substring(1, value.length - 1));
+            }
+        }
+        throw new errors.UnbalancedParenthesisError(this.bytes.position());
+    };
+    // TODO: Compare performance of string concatenation to charFromCode(...bytes)
+    // TODO: Maybe preallocate small Uint8Array if can use charFromCode?
+    PDFObjectParser.prototype.parseName = function () {
+        this.bytes.assertNext(CharCodes.default.ForwardSlash);
+        var name = '';
+        while (!this.bytes.done()) {
+            var byte = this.bytes.peek();
+            if (Whitespace.IsWhitespace[byte] || Delimiters.IsDelimiter[byte])
+                break;
+            name += strings.charFromCode(byte);
+            this.bytes.next();
+        }
+        return PDFName.default.of(name);
+    };
+    PDFObjectParser.prototype.parseArray = function () {
+        this.bytes.assertNext(CharCodes.default.LeftSquareBracket);
+        this.skipWhitespaceAndComments();
+        var pdfArray = PDFArray.default.withContext(this.context);
+        while (this.bytes.peek() !== CharCodes.default.RightSquareBracket) {
+            var element = this.parseObject();
+            pdfArray.push(element);
+            this.skipWhitespaceAndComments();
+        }
+        this.bytes.assertNext(CharCodes.default.RightSquareBracket);
+        return pdfArray;
+    };
+    PDFObjectParser.prototype.parseDict = function () {
+        this.bytes.assertNext(CharCodes.default.LessThan);
+        this.bytes.assertNext(CharCodes.default.LessThan);
+        this.skipWhitespaceAndComments();
+        var dict = new Map();
+        while (!this.bytes.done() &&
+            this.bytes.peek() !== CharCodes.default.GreaterThan &&
+            this.bytes.peekAhead(1) !== CharCodes.default.GreaterThan) {
+            var key = this.parseName();
+            var value = this.parseObject();
+            dict.set(key, value);
+            this.skipWhitespaceAndComments();
+        }
+        this.skipWhitespaceAndComments();
+        this.bytes.assertNext(CharCodes.default.GreaterThan);
+        this.bytes.assertNext(CharCodes.default.GreaterThan);
+        var Type = dict.get(PDFName.default.of('Type'));
+        if (Type === PDFName.default.of('Catalog')) {
+            return PDFCatalog.default.fromMapWithContext(dict, this.context);
+        }
+        else if (Type === PDFName.default.of('Pages')) {
+            return PDFPageTree.default.fromMapWithContext(dict, this.context);
+        }
+        else if (Type === PDFName.default.of('Page')) {
+            return PDFPageLeaf.default.fromMapWithContext(dict, this.context);
+        }
+        else {
+            return PDFDict.default.fromMapWithContext(dict, this.context);
+        }
+    };
+    PDFObjectParser.prototype.parseDictOrStream = function () {
+        var startPos = this.bytes.position();
+        var dict = this.parseDict();
+        this.skipWhitespaceAndComments();
+        if (!this.matchKeyword(Keywords.Keywords.streamEOF1) &&
+            !this.matchKeyword(Keywords.Keywords.streamEOF2) &&
+            !this.matchKeyword(Keywords.Keywords.streamEOF3) &&
+            !this.matchKeyword(Keywords.Keywords.streamEOF4) &&
+            !this.matchKeyword(Keywords.Keywords.stream)) {
+            return dict;
+        }
+        var start = this.bytes.offset();
+        var end;
+        var Length = dict.get(PDFName.default.of('Length'));
+        if (Length instanceof PDFNumber.default) {
+            end = start + Length.asNumber();
+            this.bytes.moveTo(end);
+            this.skipWhitespaceAndComments();
+            if (!this.matchKeyword(Keywords.Keywords.endstream)) {
+                this.bytes.moveTo(start);
+                end = this.findEndOfStreamFallback(startPos);
+            }
+        }
+        else {
+            end = this.findEndOfStreamFallback(startPos);
+        }
+        var contents = this.bytes.slice(start, end);
+        return PDFRawStream.default.of(dict, contents);
+    };
+    PDFObjectParser.prototype.findEndOfStreamFallback = function (startPos) {
+        // Move to end of stream, while handling nested streams
+        var nestingLvl = 1;
+        var end = this.bytes.offset();
+        while (!this.bytes.done()) {
+            end = this.bytes.offset();
+            if (this.matchKeyword(Keywords.Keywords.stream)) {
+                nestingLvl += 1;
+            }
+            else if (this.matchKeyword(Keywords.Keywords.EOF1endstream) ||
+                this.matchKeyword(Keywords.Keywords.EOF2endstream) ||
+                this.matchKeyword(Keywords.Keywords.EOF3endstream) ||
+                this.matchKeyword(Keywords.Keywords.endstream)) {
+                nestingLvl -= 1;
+            }
+            else {
+                this.bytes.next();
+            }
+            if (nestingLvl === 0)
+                break;
+        }
+        if (nestingLvl !== 0)
+            throw new errors.PDFStreamParsingError(startPos);
+        return end;
+    };
+    PDFObjectParser.forBytes = function (bytes, context, capNumbers) { return new PDFObjectParser(ByteStream.default.of(bytes), context, capNumbers); };
+    PDFObjectParser.forByteStream = function (byteStream, context, capNumbers) {
+        if (capNumbers === void 0) { capNumbers = false; }
+        return new PDFObjectParser(byteStream, context, capNumbers);
+    };
+    return PDFObjectParser;
+}(BaseParser.default));
+
+exports.default = PDFObjectParser;

package/dist/cjs/node_modules/pdf-lib/es/core/parser/PDFObjectStreamParser.js

@@ -0,0 +1,78 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+var tslib_es6 = require('../../../../tslib/tslib.es6.js');
+var errors = require('../errors.js');
+var PDFName = require('../objects/PDFName.js');
+var PDFNumber = require('../objects/PDFNumber.js');
+var PDFRef = require('../objects/PDFRef.js');
+var ByteStream = require('./ByteStream.js');
+var PDFObjectParser = require('./PDFObjectParser.js');
+require('../../utils/base64.js');
+var async = require('../../utils/async.js');
+require('../../utils/unicode.js');
+require('../../utils/objects.js');
+require('../../utils/pdfDocEncoding.js');
+require('../../utils/Cache.js');
+
+var PDFObjectStreamParser = /** @class */ (function (_super) {
+    tslib_es6.__extends(PDFObjectStreamParser, _super);
+    function PDFObjectStreamParser(rawStream, shouldWaitForTick) {
+        var _this = _super.call(this, ByteStream.default.fromPDFRawStream(rawStream), rawStream.dict.context) || this;
+        var dict = rawStream.dict;
+        _this.alreadyParsed = false;
+        _this.shouldWaitForTick = shouldWaitForTick || (function () { return false; });
+        _this.firstOffset = dict.lookup(PDFName.default.of('First'), PDFNumber.default).asNumber();
+        _this.objectCount = dict.lookup(PDFName.default.of('N'), PDFNumber.default).asNumber();
+        return _this;
+    }
+    PDFObjectStreamParser.prototype.parseIntoContext = function () {
+        return tslib_es6.__awaiter(this, void 0, void 0, function () {
+            var offsetsAndObjectNumbers, idx, len, _a, objectNumber, offset, object, ref;
+            return tslib_es6.__generator(this, function (_b) {
+                switch (_b.label) {
+                    case 0:
+                        if (this.alreadyParsed) {
+                            throw new errors.ReparseError('PDFObjectStreamParser', 'parseIntoContext');
+                        }
+                        this.alreadyParsed = true;
+                        offsetsAndObjectNumbers = this.parseOffsetsAndObjectNumbers();
+                        idx = 0, len = offsetsAndObjectNumbers.length;
+                        _b.label = 1;
+                    case 1:
+                        if (!(idx < len)) return [3 /*break*/, 4];
+                        _a = offsetsAndObjectNumbers[idx], objectNumber = _a.objectNumber, offset = _a.offset;
+                        this.bytes.moveTo(this.firstOffset + offset);
+                        object = this.parseObject();
+                        ref = PDFRef.default.of(objectNumber, 0);
+                        this.context.assign(ref, object);
+                        if (!this.shouldWaitForTick()) return [3 /*break*/, 3];
+                        return [4 /*yield*/, async.waitForTick()];
+                    case 2:
+                        _b.sent();
+                        _b.label = 3;
+                    case 3:
+                        idx++;
+                        return [3 /*break*/, 1];
+                    case 4: return [2 /*return*/];
+                }
+            });
+        });
+    };
+    PDFObjectStreamParser.prototype.parseOffsetsAndObjectNumbers = function () {
+        var offsetsAndObjectNumbers = [];
+        for (var idx = 0, len = this.objectCount; idx < len; idx++) {
+            this.skipWhitespaceAndComments();
+            var objectNumber = this.parseRawInt();
+            this.skipWhitespaceAndComments();
+            var offset = this.parseRawInt();
+            offsetsAndObjectNumbers.push({ objectNumber: objectNumber, offset: offset });
+        }
+        return offsetsAndObjectNumbers;
+    };
+    PDFObjectStreamParser.forStream = function (rawStream, shouldWaitForTick) { return new PDFObjectStreamParser(rawStream, shouldWaitForTick); };
+    return PDFObjectStreamParser;
+}(PDFObjectParser.default));
+
+exports.default = PDFObjectStreamParser;

package/dist/cjs/node_modules/pdf-lib/es/core/parser/PDFParser.js

@@ -0,0 +1,364 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+var tslib_es6 = require('../../../../tslib/tslib.es6.js');
+var PDFCrossRefSection = require('../document/PDFCrossRefSection.js');
+var PDFHeader = require('../document/PDFHeader.js');
+var PDFTrailer = require('../document/PDFTrailer.js');
+var errors = require('../errors.js');
+var PDFDict = require('../objects/PDFDict.js');
+var PDFInvalidObject = require('../objects/PDFInvalidObject.js');
+var PDFName = require('../objects/PDFName.js');
+var PDFRawStream = require('../objects/PDFRawStream.js');
+var PDFRef = require('../objects/PDFRef.js');
+var ByteStream = require('./ByteStream.js');
+var PDFObjectParser = require('./PDFObjectParser.js');
+var PDFObjectStreamParser = require('./PDFObjectStreamParser.js');
+var PDFXRefStreamParser = require('./PDFXRefStreamParser.js');
+var PDFContext = require('../PDFContext.js');
+var CharCodes = require('../syntax/CharCodes.js');
+var Keywords = require('../syntax/Keywords.js');
+var Numeric = require('../syntax/Numeric.js');
+require('../../utils/base64.js');
+var async = require('../../utils/async.js');
+require('../../utils/unicode.js');
+require('../../utils/objects.js');
+require('../../utils/pdfDocEncoding.js');
+require('../../utils/Cache.js');
+
+var PDFParser = /** @class */ (function (_super) {
+    tslib_es6.__extends(PDFParser, _super);
+    function PDFParser(pdfBytes, objectsPerTick, throwOnInvalidObject, capNumbers) {
+        if (objectsPerTick === void 0) { objectsPerTick = Infinity; }
+        if (throwOnInvalidObject === void 0) { throwOnInvalidObject = false; }
+        if (capNumbers === void 0) { capNumbers = false; }
+        var _this = _super.call(this, ByteStream.default.of(pdfBytes), PDFContext.default.create(), capNumbers) || this;
+        _this.alreadyParsed = false;
+        _this.parsedObjects = 0;
+        _this.shouldWaitForTick = function () {
+            _this.parsedObjects += 1;
+            return _this.parsedObjects % _this.objectsPerTick === 0;
+        };
+        _this.objectsPerTick = objectsPerTick;
+        _this.throwOnInvalidObject = throwOnInvalidObject;
+        return _this;
+    }
+    PDFParser.prototype.parseDocument = function () {
+        return tslib_es6.__awaiter(this, void 0, void 0, function () {
+            var prevOffset, offset;
+            return tslib_es6.__generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0:
+                        if (this.alreadyParsed) {
+                            throw new errors.ReparseError('PDFParser', 'parseDocument');
+                        }
+                        this.alreadyParsed = true;
+                        this.context.header = this.parseHeader();
+                        _a.label = 1;
+                    case 1:
+                        if (!!this.bytes.done()) return [3 /*break*/, 3];
+                        return [4 /*yield*/, this.parseDocumentSection()];
+                    case 2:
+                        _a.sent();
+                        offset = this.bytes.offset();
+                        if (offset === prevOffset) {
+                            throw new errors.StalledParserError(this.bytes.position());
+                        }
+                        prevOffset = offset;
+                        return [3 /*break*/, 1];
+                    case 3:
+                        this.maybeRecoverRoot();
+                        if (this.context.lookup(PDFRef.default.of(0))) {
+                            console.warn('Removing parsed object: 0 0 R');
+                            this.context.delete(PDFRef.default.of(0));
+                        }
+                        return [2 /*return*/, this.context];
+                }
+            });
+        });
+    };
+    PDFParser.prototype.maybeRecoverRoot = function () {
+        var isValidCatalog = function (obj) {
+            return obj instanceof PDFDict.default &&
+                obj.lookup(PDFName.default.of('Type')) === PDFName.default.of('Catalog');
+        };
+        var catalog = this.context.lookup(this.context.trailerInfo.Root);
+        if (!isValidCatalog(catalog)) {
+            var indirectObjects = this.context.enumerateIndirectObjects();
+            for (var idx = 0, len = indirectObjects.length; idx < len; idx++) {
+                var _a = indirectObjects[idx], ref = _a[0], object = _a[1];
+                if (isValidCatalog(object)) {
+                    this.context.trailerInfo.Root = ref;
+                }
+            }
+        }
+    };
+    PDFParser.prototype.parseHeader = function () {
+        while (!this.bytes.done()) {
+            if (this.matchKeyword(Keywords.Keywords.header)) {
+                var major = this.parseRawInt();
+                this.bytes.assertNext(CharCodes.default.Period);
+                var minor = this.parseRawInt();
+                var header = PDFHeader.default.forVersion(major, minor);
+                this.skipBinaryHeaderComment();
+                return header;
+            }
+            this.bytes.next();
+        }
+        throw new errors.MissingPDFHeaderError(this.bytes.position());
+    };
+    PDFParser.prototype.parseIndirectObjectHeader = function () {
+        this.skipWhitespaceAndComments();
+        var objectNumber = this.parseRawInt();
+        this.skipWhitespaceAndComments();
+        var generationNumber = this.parseRawInt();
+        this.skipWhitespaceAndComments();
+        if (!this.matchKeyword(Keywords.Keywords.obj)) {
+            throw new errors.MissingKeywordError(this.bytes.position(), Keywords.Keywords.obj);
+        }
+        return PDFRef.default.of(objectNumber, generationNumber);
+    };
+    PDFParser.prototype.matchIndirectObjectHeader = function () {
+        var initialOffset = this.bytes.offset();
+        try {
+            this.parseIndirectObjectHeader();
+            return true;
+        }
+        catch (e) {
+            this.bytes.moveTo(initialOffset);
+            return false;
+        }
+    };
+    PDFParser.prototype.parseIndirectObject = function () {
+        return tslib_es6.__awaiter(this, void 0, void 0, function () {
+            var ref, object;
+            return tslib_es6.__generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0:
+                        ref = this.parseIndirectObjectHeader();
+                        this.skipWhitespaceAndComments();
+                        object = this.parseObject();
+                        this.skipWhitespaceAndComments();
+                        // if (!this.matchKeyword(Keywords.endobj)) {
+                        // throw new MissingKeywordError(this.bytes.position(), Keywords.endobj);
+                        // }
+                        // TODO: Log a warning if this fails...
+                        this.matchKeyword(Keywords.Keywords.endobj);
+                        if (!(object instanceof PDFRawStream.default &&
+                            object.dict.lookup(PDFName.default.of('Type')) === PDFName.default.of('ObjStm'))) return [3 /*break*/, 2];
+                        return [4 /*yield*/, PDFObjectStreamParser.default.forStream(object, this.shouldWaitForTick).parseIntoContext()];
+                    case 1:
+                        _a.sent();
+                        return [3 /*break*/, 3];
+                    case 2:
+                        if (object instanceof PDFRawStream.default &&
+                            object.dict.lookup(PDFName.default.of('Type')) === PDFName.default.of('XRef')) {
+                            PDFXRefStreamParser.default.forStream(object).parseIntoContext();
+                        }
+                        else {
+                            this.context.assign(ref, object);
+                        }
+                        _a.label = 3;
+                    case 3: return [2 /*return*/, ref];
+                }
+            });
+        });
+    };
+    // TODO: Improve and clean this up
+    PDFParser.prototype.tryToParseInvalidIndirectObject = function () {
+        var startPos = this.bytes.position();
+        var msg = "Trying to parse invalid object: " + JSON.stringify(startPos) + ")";
+        if (this.throwOnInvalidObject)
+            throw new Error(msg);
+        console.warn(msg);
+        var ref = this.parseIndirectObjectHeader();
+        console.warn("Invalid object ref: " + ref);
+        this.skipWhitespaceAndComments();
+        var start = this.bytes.offset();
+        var failed = true;
+        while (!this.bytes.done()) {
+            if (this.matchKeyword(Keywords.Keywords.endobj)) {
+                failed = false;
+            }
+            if (!failed)
+                break;
+            this.bytes.next();
+        }
+        if (failed)
+            throw new errors.PDFInvalidObjectParsingError(startPos);
+        var end = this.bytes.offset() - Keywords.Keywords.endobj.length;
+        var object = PDFInvalidObject.default.of(this.bytes.slice(start, end));
+        this.context.assign(ref, object);
+        return ref;
+    };
+    PDFParser.prototype.parseIndirectObjects = function () {
+        return tslib_es6.__awaiter(this, void 0, void 0, function () {
+            var initialOffset;
+            return tslib_es6.__generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0:
+                        this.skipWhitespaceAndComments();
+                        _a.label = 1;
+                    case 1:
+                        if (!(!this.bytes.done() && Numeric.IsDigit[this.bytes.peek()])) return [3 /*break*/, 8];
+                        initialOffset = this.bytes.offset();
+                        _a.label = 2;
+                    case 2:
+                        _a.trys.push([2, 4, , 5]);
+                        return [4 /*yield*/, this.parseIndirectObject()];
+                    case 3:
+                        _a.sent();
+                        return [3 /*break*/, 5];
+                    case 4:
+                        _a.sent();
+                        // TODO: Add tracing/logging mechanism to track when this happens!
+                        this.bytes.moveTo(initialOffset);
+                        this.tryToParseInvalidIndirectObject();
+                        return [3 /*break*/, 5];
+                    case 5:
+                        this.skipWhitespaceAndComments();
+                        // TODO: Can this be done only when needed, to avoid harming performance?
+                        this.skipJibberish();
+                        if (!this.shouldWaitForTick()) return [3 /*break*/, 7];
+                        return [4 /*yield*/, async.waitForTick()];
+                    case 6:
+                        _a.sent();
+                        _a.label = 7;
+                    case 7: return [3 /*break*/, 1];
+                    case 8: return [2 /*return*/];
+                }
+            });
+        });
+    };
+    PDFParser.prototype.maybeParseCrossRefSection = function () {
+        this.skipWhitespaceAndComments();
+        if (!this.matchKeyword(Keywords.Keywords.xref))
+            return;
+        this.skipWhitespaceAndComments();
+        var objectNumber = -1;
+        var xref = PDFCrossRefSection.default.createEmpty();
+        while (!this.bytes.done() && Numeric.IsDigit[this.bytes.peek()]) {
+            var firstInt = this.parseRawInt();
+            this.skipWhitespaceAndComments();
+            var secondInt = this.parseRawInt();
+            this.skipWhitespaceAndComments();
+            var byte = this.bytes.peek();
+            if (byte === CharCodes.default.n || byte === CharCodes.default.f) {
+                var ref = PDFRef.default.of(objectNumber, secondInt);
+                if (this.bytes.next() === CharCodes.default.n) {
+                    xref.addEntry(ref, firstInt);
+                }
+                else {
+                    // this.context.delete(ref);
+                    xref.addDeletedEntry(ref, firstInt);
+                }
+                objectNumber += 1;
+            }
+            else {
+                objectNumber = firstInt;
+            }
+            this.skipWhitespaceAndComments();
+        }
+        return xref;
+    };
+    PDFParser.prototype.maybeParseTrailerDict = function () {
+        this.skipWhitespaceAndComments();
+        if (!this.matchKeyword(Keywords.Keywords.trailer))
+            return;
+        this.skipWhitespaceAndComments();
+        var dict = this.parseDict();
+        var context = this.context;
+        context.trailerInfo = {
+            Root: dict.get(PDFName.default.of('Root')) || context.trailerInfo.Root,
+            Encrypt: dict.get(PDFName.default.of('Encrypt')) || context.trailerInfo.Encrypt,
+            Info: dict.get(PDFName.default.of('Info')) || context.trailerInfo.Info,
+            ID: dict.get(PDFName.default.of('ID')) || context.trailerInfo.ID,
+        };
+    };
+    PDFParser.prototype.maybeParseTrailer = function () {
+        this.skipWhitespaceAndComments();
+        if (!this.matchKeyword(Keywords.Keywords.startxref))
+            return;
+        this.skipWhitespaceAndComments();
+        var offset = this.parseRawInt();
+        this.skipWhitespace();
+        this.matchKeyword(Keywords.Keywords.eof);
+        this.skipWhitespaceAndComments();
+        this.matchKeyword(Keywords.Keywords.eof);
+        this.skipWhitespaceAndComments();
+        return PDFTrailer.default.forLastCrossRefSectionOffset(offset);
+    };
+    PDFParser.prototype.parseDocumentSection = function () {
+        return tslib_es6.__awaiter(this, void 0, void 0, function () {
+            return tslib_es6.__generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0: return [4 /*yield*/, this.parseIndirectObjects()];
+                    case 1:
+                        _a.sent();
+                        this.maybeParseCrossRefSection();
+                        this.maybeParseTrailerDict();
+                        this.maybeParseTrailer();
+                        // TODO: Can this be done only when needed, to avoid harming performance?
+                        this.skipJibberish();
+                        return [2 /*return*/];
+                }
+            });
+        });
+    };
+    /**
+     * This operation is not necessary for valid PDF files. But some invalid PDFs
+     * contain jibberish in between indirect objects. This method is designed to
+     * skip past that jibberish, should it exist, until it reaches the next
+     * indirect object header, an xref table section, or the file trailer.
+     */
+    PDFParser.prototype.skipJibberish = function () {
+        this.skipWhitespaceAndComments();
+        while (!this.bytes.done()) {
+            var initialOffset = this.bytes.offset();
+            var byte = this.bytes.peek();
+            var isAlphaNumeric = byte >= CharCodes.default.Space && byte <= CharCodes.default.Tilde;
+            if (isAlphaNumeric) {
+                if (this.matchKeyword(Keywords.Keywords.xref) ||
+                    this.matchKeyword(Keywords.Keywords.trailer) ||
+                    this.matchKeyword(Keywords.Keywords.startxref) ||
+                    this.matchIndirectObjectHeader()) {
+                    this.bytes.moveTo(initialOffset);
+                    break;
+                }
+            }
+            this.bytes.next();
+        }
+    };
+    /**
+     * Skips the binary comment following a PDF header. The specification
+     * defines this binary comment (section 7.5.2 File Header) as a sequence of 4
+     * or more bytes that are 128 or greater, and which are preceded by a "%".
+     *
+     * This would imply that to strip out this binary comment, we could check for
+     * a sequence of bytes starting with "%", and remove all subsequent bytes that
+     * are 128 or greater. This works for many documents that properly comply with
+     * the spec. But in the wild, there are PDFs that omit the leading "%", and
+     * include bytes that are less than 128 (e.g. 0 or 1). So in order to parse
+     * these headers correctly, we just throw out all bytes leading up to the
+     * first indirect object header.
+     */
+    PDFParser.prototype.skipBinaryHeaderComment = function () {
+        this.skipWhitespaceAndComments();
+        try {
+            var initialOffset = this.bytes.offset();
+            this.parseIndirectObjectHeader();
+            this.bytes.moveTo(initialOffset);
+        }
+        catch (e) {
+            this.bytes.next();
+            this.skipWhitespaceAndComments();
+        }
+    };
+    PDFParser.forBytesWithOptions = function (pdfBytes, objectsPerTick, throwOnInvalidObject, capNumbers) {
+        return new PDFParser(pdfBytes, objectsPerTick, throwOnInvalidObject, capNumbers);
+    };
+    return PDFParser;
+}(PDFObjectParser.default));
+
+exports.default = PDFParser;