art-bd-ui 1.0.21 → 1.0.23

package/dist/esm/node_modules/pdf-lib/es/core/objects/PDFString.js

@@ -0,0 +1,120 @@
+import { __extends } from '../../../../tslib/tslib.es6.js';
+import PDFObject from './PDFObject.js';
+import CharCodes from '../syntax/CharCodes.js';
+import '../../utils/base64.js';
+import { toCharCode, parseDate, copyStringIntoBuffer, padStart } from '../../utils/strings.js';
+import { hasUtf16BOM, utf16Decode } from '../../utils/unicode.js';
+import '../../utils/objects.js';
+import { pdfDocEncodingDecode } from '../../utils/pdfDocEncoding.js';
+import '../../utils/Cache.js';
+import { InvalidPDFDateStringError } from '../errors.js';
+
+var PDFString = /** @class */ (function (_super) {
+    __extends(PDFString, _super);
+    function PDFString(value) {
+        var _this = _super.call(this) || this;
+        _this.value = value;
+        return _this;
+    }
+    PDFString.prototype.asBytes = function () {
+        var bytes = [];
+        var octal = '';
+        var escaped = false;
+        var pushByte = function (byte) {
+            if (byte !== undefined)
+                bytes.push(byte);
+            escaped = false;
+        };
+        for (var idx = 0, len = this.value.length; idx < len; idx++) {
+            var char = this.value[idx];
+            var byte = toCharCode(char);
+            var nextChar = this.value[idx + 1];
+            if (!escaped) {
+                if (byte === CharCodes.BackSlash)
+                    escaped = true;
+                else
+                    pushByte(byte);
+            }
+            else {
+                if (byte === CharCodes.Newline)
+                    pushByte();
+                else if (byte === CharCodes.CarriageReturn)
+                    pushByte();
+                else if (byte === CharCodes.n)
+                    pushByte(CharCodes.Newline);
+                else if (byte === CharCodes.r)
+                    pushByte(CharCodes.CarriageReturn);
+                else if (byte === CharCodes.t)
+                    pushByte(CharCodes.Tab);
+                else if (byte === CharCodes.b)
+                    pushByte(CharCodes.Backspace);
+                else if (byte === CharCodes.f)
+                    pushByte(CharCodes.FormFeed);
+                else if (byte === CharCodes.LeftParen)
+                    pushByte(CharCodes.LeftParen);
+                else if (byte === CharCodes.RightParen)
+                    pushByte(CharCodes.RightParen);
+                else if (byte === CharCodes.Backspace)
+                    pushByte(CharCodes.BackSlash);
+                else if (byte >= CharCodes.Zero && byte <= CharCodes.Seven) {
+                    octal += char;
+                    if (octal.length === 3 || !(nextChar >= '0' && nextChar <= '7')) {
+                        pushByte(parseInt(octal, 8));
+                        octal = '';
+                    }
+                }
+                else {
+                    pushByte(byte);
+                }
+            }
+        }
+        return new Uint8Array(bytes);
+    };
+    PDFString.prototype.decodeText = function () {
+        var bytes = this.asBytes();
+        if (hasUtf16BOM(bytes))
+            return utf16Decode(bytes);
+        return pdfDocEncodingDecode(bytes);
+    };
+    PDFString.prototype.decodeDate = function () {
+        var text = this.decodeText();
+        var date = parseDate(text);
+        if (!date)
+            throw new InvalidPDFDateStringError(text);
+        return date;
+    };
+    PDFString.prototype.asString = function () {
+        return this.value;
+    };
+    PDFString.prototype.clone = function () {
+        return PDFString.of(this.value);
+    };
+    PDFString.prototype.toString = function () {
+        return "(" + this.value + ")";
+    };
+    PDFString.prototype.sizeInBytes = function () {
+        return this.value.length + 2;
+    };
+    PDFString.prototype.copyBytesInto = function (buffer, offset) {
+        buffer[offset++] = CharCodes.LeftParen;
+        offset += copyStringIntoBuffer(this.value, buffer, offset);
+        buffer[offset++] = CharCodes.RightParen;
+        return this.value.length + 2;
+    };
+    // The PDF spec allows newlines and parens to appear directly within a literal
+    // string. These character _may_ be escaped. But they do not _have_ to be. So
+    // for simplicity, we will not bother escaping them.
+    PDFString.of = function (value) { return new PDFString(value); };
+    PDFString.fromDate = function (date) {
+        var year = padStart(String(date.getUTCFullYear()), 4, '0');
+        var month = padStart(String(date.getUTCMonth() + 1), 2, '0');
+        var day = padStart(String(date.getUTCDate()), 2, '0');
+        var hours = padStart(String(date.getUTCHours()), 2, '0');
+        var mins = padStart(String(date.getUTCMinutes()), 2, '0');
+        var secs = padStart(String(date.getUTCSeconds()), 2, '0');
+        return new PDFString("D:" + year + month + day + hours + mins + secs + "Z");
+    };
+    return PDFString;
+}(PDFObject));
+
+export { PDFString as default };

package/dist/esm/node_modules/pdf-lib/es/core/operators/PDFOperator.js

@@ -0,0 +1,61 @@
+import PDFObject from '../objects/PDFObject.js';
+import CharCodes from '../syntax/CharCodes.js';
+import '../../utils/base64.js';
+import { copyStringIntoBuffer } from '../../utils/strings.js';
+import '../../utils/unicode.js';
+import '../../utils/objects.js';
+import '../../utils/pdfDocEncoding.js';
+import '../../utils/Cache.js';
+
+var PDFOperator = /** @class */ (function () {
+    function PDFOperator(name, args) {
+        this.name = name;
+        this.args = args || [];
+    }
+    PDFOperator.prototype.clone = function (context) {
+        var args = new Array(this.args.length);
+        for (var idx = 0, len = args.length; idx < len; idx++) {
+            var arg = this.args[idx];
+            args[idx] = arg instanceof PDFObject ? arg.clone(context) : arg;
+        }
+        return PDFOperator.of(this.name, args);
+    };
+    PDFOperator.prototype.toString = function () {
+        var value = '';
+        for (var idx = 0, len = this.args.length; idx < len; idx++) {
+            value += String(this.args[idx]) + ' ';
+        }
+        value += this.name;
+        return value;
+    };
+    PDFOperator.prototype.sizeInBytes = function () {
+        var size = 0;
+        for (var idx = 0, len = this.args.length; idx < len; idx++) {
+            var arg = this.args[idx];
+            size += (arg instanceof PDFObject ? arg.sizeInBytes() : arg.length) + 1;
+        }
+        size += this.name.length;
+        return size;
+    };
+    PDFOperator.prototype.copyBytesInto = function (buffer, offset) {
+        var initialOffset = offset;
+        for (var idx = 0, len = this.args.length; idx < len; idx++) {
+            var arg = this.args[idx];
+            if (arg instanceof PDFObject) {
+                offset += arg.copyBytesInto(buffer, offset);
+            }
+            else {
+                offset += copyStringIntoBuffer(arg, buffer, offset);
+            }
+            buffer[offset++] = CharCodes.Space;
+        }
+        offset += copyStringIntoBuffer(this.name, buffer, offset);
+        return offset - initialOffset;
+    };
+    PDFOperator.of = function (name, args) {
+        return new PDFOperator(name, args);
+    };
+    return PDFOperator;
+}());
+
+export { PDFOperator as default };

package/dist/esm/node_modules/pdf-lib/es/core/operators/PDFOperatorNames.js

@@ -0,0 +1,87 @@
+var PDFOperatorNames;
+(function (PDFOperatorNames) {
+    // Non Stroking Color Operators
+    PDFOperatorNames["NonStrokingColor"] = "sc";
+    PDFOperatorNames["NonStrokingColorN"] = "scn";
+    PDFOperatorNames["NonStrokingColorRgb"] = "rg";
+    PDFOperatorNames["NonStrokingColorGray"] = "g";
+    PDFOperatorNames["NonStrokingColorCmyk"] = "k";
+    PDFOperatorNames["NonStrokingColorspace"] = "cs";
+    // Stroking Color Operators
+    PDFOperatorNames["StrokingColor"] = "SC";
+    PDFOperatorNames["StrokingColorN"] = "SCN";
+    PDFOperatorNames["StrokingColorRgb"] = "RG";
+    PDFOperatorNames["StrokingColorGray"] = "G";
+    PDFOperatorNames["StrokingColorCmyk"] = "K";
+    PDFOperatorNames["StrokingColorspace"] = "CS";
+    // Marked Content Operators
+    PDFOperatorNames["BeginMarkedContentSequence"] = "BDC";
+    PDFOperatorNames["BeginMarkedContent"] = "BMC";
+    PDFOperatorNames["EndMarkedContent"] = "EMC";
+    PDFOperatorNames["MarkedContentPointWithProps"] = "DP";
+    PDFOperatorNames["MarkedContentPoint"] = "MP";
+    PDFOperatorNames["DrawObject"] = "Do";
+    // Graphics State Operators
+    PDFOperatorNames["ConcatTransformationMatrix"] = "cm";
+    PDFOperatorNames["PopGraphicsState"] = "Q";
+    PDFOperatorNames["PushGraphicsState"] = "q";
+    PDFOperatorNames["SetFlatness"] = "i";
+    PDFOperatorNames["SetGraphicsStateParams"] = "gs";
+    PDFOperatorNames["SetLineCapStyle"] = "J";
+    PDFOperatorNames["SetLineDashPattern"] = "d";
+    PDFOperatorNames["SetLineJoinStyle"] = "j";
+    PDFOperatorNames["SetLineMiterLimit"] = "M";
+    PDFOperatorNames["SetLineWidth"] = "w";
+    PDFOperatorNames["SetTextMatrix"] = "Tm";
+    PDFOperatorNames["SetRenderingIntent"] = "ri";
+    // Graphics Operators
+    PDFOperatorNames["AppendRectangle"] = "re";
+    PDFOperatorNames["BeginInlineImage"] = "BI";
+    PDFOperatorNames["BeginInlineImageData"] = "ID";
+    PDFOperatorNames["EndInlineImage"] = "EI";
+    PDFOperatorNames["ClipEvenOdd"] = "W*";
+    PDFOperatorNames["ClipNonZero"] = "W";
+    PDFOperatorNames["CloseAndStroke"] = "s";
+    PDFOperatorNames["CloseFillEvenOddAndStroke"] = "b*";
+    PDFOperatorNames["CloseFillNonZeroAndStroke"] = "b";
+    PDFOperatorNames["ClosePath"] = "h";
+    PDFOperatorNames["AppendBezierCurve"] = "c";
+    PDFOperatorNames["CurveToReplicateFinalPoint"] = "y";
+    PDFOperatorNames["CurveToReplicateInitialPoint"] = "v";
+    PDFOperatorNames["EndPath"] = "n";
+    PDFOperatorNames["FillEvenOddAndStroke"] = "B*";
+    PDFOperatorNames["FillEvenOdd"] = "f*";
+    PDFOperatorNames["FillNonZeroAndStroke"] = "B";
+    PDFOperatorNames["FillNonZero"] = "f";
+    PDFOperatorNames["LegacyFillNonZero"] = "F";
+    PDFOperatorNames["LineTo"] = "l";
+    PDFOperatorNames["MoveTo"] = "m";
+    PDFOperatorNames["ShadingFill"] = "sh";
+    PDFOperatorNames["StrokePath"] = "S";
+    // Text Operators
+    PDFOperatorNames["BeginText"] = "BT";
+    PDFOperatorNames["EndText"] = "ET";
+    PDFOperatorNames["MoveText"] = "Td";
+    PDFOperatorNames["MoveTextSetLeading"] = "TD";
+    PDFOperatorNames["NextLine"] = "T*";
+    PDFOperatorNames["SetCharacterSpacing"] = "Tc";
+    PDFOperatorNames["SetFontAndSize"] = "Tf";
+    PDFOperatorNames["SetTextHorizontalScaling"] = "Tz";
+    PDFOperatorNames["SetTextLineHeight"] = "TL";
+    PDFOperatorNames["SetTextRenderingMode"] = "Tr";
+    PDFOperatorNames["SetTextRise"] = "Ts";
+    PDFOperatorNames["SetWordSpacing"] = "Tw";
+    PDFOperatorNames["ShowText"] = "Tj";
+    PDFOperatorNames["ShowTextAdjusted"] = "TJ";
+    PDFOperatorNames["ShowTextLine"] = "'";
+    PDFOperatorNames["ShowTextLineAndSpace"] = "\"";
+    // Type3 Font Operators
+    PDFOperatorNames["Type3D0"] = "d0";
+    PDFOperatorNames["Type3D1"] = "d1";
+    // Compatibility Section Operators
+    PDFOperatorNames["BeginCompatibilitySection"] = "BX";
+    PDFOperatorNames["EndCompatibilitySection"] = "EX";
+})(PDFOperatorNames || (PDFOperatorNames = {}));
+var Ops = PDFOperatorNames;
+
+export { Ops as default };

package/dist/esm/node_modules/pdf-lib/es/core/parser/BaseParser.js

@@ -0,0 +1,113 @@
+import { NumberParsingError } from '../errors.js';
+import CharCodes from '../syntax/CharCodes.js';
+import { IsDigit, IsNumeric } from '../syntax/Numeric.js';
+import { IsWhitespace } from '../syntax/Whitespace.js';
+import '../../utils/base64.js';
+import { charFromCode } from '../../utils/strings.js';
+import '../../utils/unicode.js';
+import '../../utils/objects.js';
+import '../../utils/pdfDocEncoding.js';
+import '../../utils/Cache.js';
+
+var Newline = CharCodes.Newline, CarriageReturn = CharCodes.CarriageReturn;
+// TODO: Throw error if eof is reached before finishing object parse...
+var BaseParser = /** @class */ (function () {
+    function BaseParser(bytes, capNumbers) {
+        if (capNumbers === void 0) { capNumbers = false; }
+        this.bytes = bytes;
+        this.capNumbers = capNumbers;
+    }
+    BaseParser.prototype.parseRawInt = function () {
+        var value = '';
+        while (!this.bytes.done()) {
+            var byte = this.bytes.peek();
+            if (!IsDigit[byte])
+                break;
+            value += charFromCode(this.bytes.next());
+        }
+        var numberValue = Number(value);
+        if (!value || !isFinite(numberValue)) {
+            throw new NumberParsingError(this.bytes.position(), value);
+        }
+        return numberValue;
+    };
+    // TODO: Maybe handle exponential format?
+    // TODO: Compare performance of string concatenation to charFromCode(...bytes)
+    BaseParser.prototype.parseRawNumber = function () {
+        var value = '';
+        // Parse integer-part, the leading (+ | - | . | 0-9)
+        while (!this.bytes.done()) {
+            var byte = this.bytes.peek();
+            if (!IsNumeric[byte])
+                break;
+            value += charFromCode(this.bytes.next());
+            if (byte === CharCodes.Period)
+                break;
+        }
+        // Parse decimal-part, the trailing (0-9)
+        while (!this.bytes.done()) {
+            var byte = this.bytes.peek();
+            if (!IsDigit[byte])
+                break;
+            value += charFromCode(this.bytes.next());
+        }
+        var numberValue = Number(value);
+        if (!value || !isFinite(numberValue)) {
+            throw new NumberParsingError(this.bytes.position(), value);
+        }
+        if (numberValue > Number.MAX_SAFE_INTEGER) {
+            if (this.capNumbers) {
+                var msg = "Parsed number that is too large for some PDF readers: " + value + ", using Number.MAX_SAFE_INTEGER instead.";
+                console.warn(msg);
+                return Number.MAX_SAFE_INTEGER;
+            }
+            else {
+                var msg = "Parsed number that is too large for some PDF readers: " + value + ", not capping.";
+                console.warn(msg);
+            }
+        }
+        return numberValue;
+    };
+    BaseParser.prototype.skipWhitespace = function () {
+        while (!this.bytes.done() && IsWhitespace[this.bytes.peek()]) {
+            this.bytes.next();
+        }
+    };
+    BaseParser.prototype.skipLine = function () {
+        while (!this.bytes.done()) {
+            var byte = this.bytes.peek();
+            if (byte === Newline || byte === CarriageReturn)
+                return;
+            this.bytes.next();
+        }
+    };
+    BaseParser.prototype.skipComment = function () {
+        if (this.bytes.peek() !== CharCodes.Percent)
+            return false;
+        while (!this.bytes.done()) {
+            var byte = this.bytes.peek();
+            if (byte === Newline || byte === CarriageReturn)
+                return true;
+            this.bytes.next();
+        }
+        return true;
+    };
+    BaseParser.prototype.skipWhitespaceAndComments = function () {
+        this.skipWhitespace();
+        while (this.skipComment())
+            this.skipWhitespace();
+    };
+    BaseParser.prototype.matchKeyword = function (keyword) {
+        var initialOffset = this.bytes.offset();
+        for (var idx = 0, len = keyword.length; idx < len; idx++) {
+            if (this.bytes.done() || this.bytes.next() !== keyword[idx]) {
+                this.bytes.moveTo(initialOffset);
+                return false;
+            }
+        }
+        return true;
+    };
+    return BaseParser;
+}());
+
+export { BaseParser as default };

package/dist/esm/node_modules/pdf-lib/es/core/parser/ByteStream.js

@@ -0,0 +1,62 @@
+import { NextByteAssertionError } from '../errors.js';
+import { decodePDFRawStream } from '../streams/decode.js';
+import CharCodes from '../syntax/CharCodes.js';
+
+// TODO: See how line/col tracking affects performance
+var ByteStream = /** @class */ (function () {
+    function ByteStream(bytes) {
+        this.idx = 0;
+        this.line = 0;
+        this.column = 0;
+        this.bytes = bytes;
+        this.length = this.bytes.length;
+    }
+    ByteStream.prototype.moveTo = function (offset) {
+        this.idx = offset;
+    };
+    ByteStream.prototype.next = function () {
+        var byte = this.bytes[this.idx++];
+        if (byte === CharCodes.Newline) {
+            this.line += 1;
+            this.column = 0;
+        }
+        else {
+            this.column += 1;
+        }
+        return byte;
+    };
+    ByteStream.prototype.assertNext = function (expected) {
+        if (this.peek() !== expected) {
+            throw new NextByteAssertionError(this.position(), expected, this.peek());
+        }
+        return this.next();
+    };
+    ByteStream.prototype.peek = function () {
+        return this.bytes[this.idx];
+    };
+    ByteStream.prototype.peekAhead = function (steps) {
+        return this.bytes[this.idx + steps];
+    };
+    ByteStream.prototype.peekAt = function (offset) {
+        return this.bytes[offset];
+    };
+    ByteStream.prototype.done = function () {
+        return this.idx >= this.length;
+    };
+    ByteStream.prototype.offset = function () {
+        return this.idx;
+    };
+    ByteStream.prototype.slice = function (start, end) {
+        return this.bytes.slice(start, end);
+    };
+    ByteStream.prototype.position = function () {
+        return { line: this.line, column: this.column, offset: this.idx };
+    };
+    ByteStream.of = function (bytes) { return new ByteStream(bytes); };
+    ByteStream.fromPDFRawStream = function (rawStream) {
+        return ByteStream.of(decodePDFRawStream(rawStream).decode());
+    };
+    return ByteStream;
+}());
+
+export { ByteStream as default };

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

@@ -0,0 +1,237 @@
+import { __extends } from '../../../../tslib/tslib.es6.js';
+import { PDFObjectParsingError, UnbalancedParenthesisError, PDFStreamParsingError } from '../errors.js';
+import PDFArray from '../objects/PDFArray.js';
+import PDFBool from '../objects/PDFBool.js';
+import PDFDict from '../objects/PDFDict.js';
+import PDFHexString from '../objects/PDFHexString.js';
+import PDFName from '../objects/PDFName.js';
+import PDFNull from '../objects/PDFNull.js';
+import PDFNumber from '../objects/PDFNumber.js';
+import PDFRawStream from '../objects/PDFRawStream.js';
+import PDFRef from '../objects/PDFRef.js';
+import PDFString from '../objects/PDFString.js';
+import BaseParser from './BaseParser.js';
+import ByteStream from './ByteStream.js';
+import PDFCatalog from '../structures/PDFCatalog.js';
+import PDFPageLeaf from '../structures/PDFPageLeaf.js';
+import PDFPageTree from '../structures/PDFPageTree.js';
+import CharCodes from '../syntax/CharCodes.js';
+import { IsDelimiter } from '../syntax/Delimiters.js';
+import { Keywords } from '../syntax/Keywords.js';
+import { IsNumeric, IsDigit } from '../syntax/Numeric.js';
+import { IsWhitespace } from '../syntax/Whitespace.js';
+import '../../utils/base64.js';
+import { charFromCode } from '../../utils/strings.js';
+import '../../utils/unicode.js';
+import '../../utils/objects.js';
+import '../../utils/pdfDocEncoding.js';
+import '../../utils/Cache.js';
+
+// TODO: Throw error if eof is reached before finishing object parse...
+var PDFObjectParser = /** @class */ (function (_super) {
+    __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.true))
+            return PDFBool.True;
+        if (this.matchKeyword(Keywords.false))
+            return PDFBool.False;
+        if (this.matchKeyword(Keywords.null))
+            return PDFNull;
+        var byte = this.bytes.peek();
+        if (byte === CharCodes.LessThan &&
+            this.bytes.peekAhead(1) === CharCodes.LessThan) {
+            return this.parseDictOrStream();
+        }
+        if (byte === CharCodes.LessThan)
+            return this.parseHexString();
+        if (byte === CharCodes.LeftParen)
+            return this.parseString();
+        if (byte === CharCodes.ForwardSlash)
+            return this.parseName();
+        if (byte === CharCodes.LeftSquareBracket)
+            return this.parseArray();
+        if (IsNumeric[byte])
+            return this.parseNumberOrRef();
+        throw new PDFObjectParsingError(this.bytes.position(), byte);
+    };
+    PDFObjectParser.prototype.parseNumberOrRef = function () {
+        var firstNum = this.parseRawNumber();
+        this.skipWhitespaceAndComments();
+        var lookaheadStart = this.bytes.offset();
+        if (IsDigit[this.bytes.peek()]) {
+            var secondNum = this.parseRawNumber();
+            this.skipWhitespaceAndComments();
+            if (this.bytes.peek() === CharCodes.R) {
+                this.bytes.assertNext(CharCodes.R);
+                return PDFRef.of(firstNum, secondNum);
+            }
+        }
+        this.bytes.moveTo(lookaheadStart);
+        return PDFNumber.of(firstNum);
+    };
+    // TODO: Maybe update PDFHexString.of() logic to remove whitespace and validate input?
+    PDFObjectParser.prototype.parseHexString = function () {
+        var value = '';
+        this.bytes.assertNext(CharCodes.LessThan);
+        while (!this.bytes.done() && this.bytes.peek() !== CharCodes.GreaterThan) {
+            value += charFromCode(this.bytes.next());
+        }
+        this.bytes.assertNext(CharCodes.GreaterThan);
+        return PDFHexString.of(value);
+    };
+    PDFObjectParser.prototype.parseString = function () {
+        var nestingLvl = 0;
+        var isEscaped = false;
+        var value = '';
+        while (!this.bytes.done()) {
+            var byte = this.bytes.next();
+            value += charFromCode(byte);
+            // Check for unescaped parenthesis
+            if (!isEscaped) {
+                if (byte === CharCodes.LeftParen)
+                    nestingLvl += 1;
+                if (byte === CharCodes.RightParen)
+                    nestingLvl -= 1;
+            }
+            // Track whether current character is being escaped or not
+            if (byte === CharCodes.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.of(value.substring(1, value.length - 1));
+            }
+        }
+        throw new 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.ForwardSlash);
+        var name = '';
+        while (!this.bytes.done()) {
+            var byte = this.bytes.peek();
+            if (IsWhitespace[byte] || IsDelimiter[byte])
+                break;
+            name += charFromCode(byte);
+            this.bytes.next();
+        }
+        return PDFName.of(name);
+    };
+    PDFObjectParser.prototype.parseArray = function () {
+        this.bytes.assertNext(CharCodes.LeftSquareBracket);
+        this.skipWhitespaceAndComments();
+        var pdfArray = PDFArray.withContext(this.context);
+        while (this.bytes.peek() !== CharCodes.RightSquareBracket) {
+            var element = this.parseObject();
+            pdfArray.push(element);
+            this.skipWhitespaceAndComments();
+        }
+        this.bytes.assertNext(CharCodes.RightSquareBracket);
+        return pdfArray;
+    };
+    PDFObjectParser.prototype.parseDict = function () {
+        this.bytes.assertNext(CharCodes.LessThan);
+        this.bytes.assertNext(CharCodes.LessThan);
+        this.skipWhitespaceAndComments();
+        var dict = new Map();
+        while (!this.bytes.done() &&
+            this.bytes.peek() !== CharCodes.GreaterThan &&
+            this.bytes.peekAhead(1) !== CharCodes.GreaterThan) {
+            var key = this.parseName();
+            var value = this.parseObject();
+            dict.set(key, value);
+            this.skipWhitespaceAndComments();
+        }
+        this.skipWhitespaceAndComments();
+        this.bytes.assertNext(CharCodes.GreaterThan);
+        this.bytes.assertNext(CharCodes.GreaterThan);
+        var Type = dict.get(PDFName.of('Type'));
+        if (Type === PDFName.of('Catalog')) {
+            return PDFCatalog.fromMapWithContext(dict, this.context);
+        }
+        else if (Type === PDFName.of('Pages')) {
+            return PDFPageTree.fromMapWithContext(dict, this.context);
+        }
+        else if (Type === PDFName.of('Page')) {
+            return PDFPageLeaf.fromMapWithContext(dict, this.context);
+        }
+        else {
+            return PDFDict.fromMapWithContext(dict, this.context);
+        }
+    };
+    PDFObjectParser.prototype.parseDictOrStream = function () {
+        var startPos = this.bytes.position();
+        var dict = this.parseDict();
+        this.skipWhitespaceAndComments();
+        if (!this.matchKeyword(Keywords.streamEOF1) &&
+            !this.matchKeyword(Keywords.streamEOF2) &&
+            !this.matchKeyword(Keywords.streamEOF3) &&
+            !this.matchKeyword(Keywords.streamEOF4) &&
+            !this.matchKeyword(Keywords.stream)) {
+            return dict;
+        }
+        var start = this.bytes.offset();
+        var end;
+        var Length = dict.get(PDFName.of('Length'));
+        if (Length instanceof PDFNumber) {
+            end = start + Length.asNumber();
+            this.bytes.moveTo(end);
+            this.skipWhitespaceAndComments();
+            if (!this.matchKeyword(Keywords.endstream)) {
+                this.bytes.moveTo(start);
+                end = this.findEndOfStreamFallback(startPos);
+            }
+        }
+        else {
+            end = this.findEndOfStreamFallback(startPos);
+        }
+        var contents = this.bytes.slice(start, end);
+        return PDFRawStream.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.stream)) {
+                nestingLvl += 1;
+            }
+            else if (this.matchKeyword(Keywords.EOF1endstream) ||
+                this.matchKeyword(Keywords.EOF2endstream) ||
+                this.matchKeyword(Keywords.EOF3endstream) ||
+                this.matchKeyword(Keywords.endstream)) {
+                nestingLvl -= 1;
+            }
+            else {
+                this.bytes.next();
+            }
+            if (nestingLvl === 0)
+                break;
+        }
+        if (nestingLvl !== 0)
+            throw new PDFStreamParsingError(startPos);
+        return end;
+    };
+    PDFObjectParser.forBytes = function (bytes, context, capNumbers) { return new PDFObjectParser(ByteStream.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));
+
+export { PDFObjectParser as default };