art-bd-ui 1.0.21 → 1.0.23

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

@@ -0,0 +1,74 @@
+import { __extends, __awaiter, __generator } from '../../../../tslib/tslib.es6.js';
+import { ReparseError } from '../errors.js';
+import PDFName from '../objects/PDFName.js';
+import PDFNumber from '../objects/PDFNumber.js';
+import PDFRef from '../objects/PDFRef.js';
+import ByteStream from './ByteStream.js';
+import PDFObjectParser from './PDFObjectParser.js';
+import '../../utils/base64.js';
+import { waitForTick } from '../../utils/async.js';
+import '../../utils/unicode.js';
+import '../../utils/objects.js';
+import '../../utils/pdfDocEncoding.js';
+import '../../utils/Cache.js';
+
+var PDFObjectStreamParser = /** @class */ (function (_super) {
+    __extends(PDFObjectStreamParser, _super);
+    function PDFObjectStreamParser(rawStream, shouldWaitForTick) {
+        var _this = _super.call(this, ByteStream.fromPDFRawStream(rawStream), rawStream.dict.context) || this;
+        var dict = rawStream.dict;
+        _this.alreadyParsed = false;
+        _this.shouldWaitForTick = shouldWaitForTick || (function () { return false; });
+        _this.firstOffset = dict.lookup(PDFName.of('First'), PDFNumber).asNumber();
+        _this.objectCount = dict.lookup(PDFName.of('N'), PDFNumber).asNumber();
+        return _this;
+    }
+    PDFObjectStreamParser.prototype.parseIntoContext = function () {
+        return __awaiter(this, void 0, void 0, function () {
+            var offsetsAndObjectNumbers, idx, len, _a, objectNumber, offset, object, ref;
+            return __generator(this, function (_b) {
+                switch (_b.label) {
+                    case 0:
+                        if (this.alreadyParsed) {
+                            throw new 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.of(objectNumber, 0);
+                        this.context.assign(ref, object);
+                        if (!this.shouldWaitForTick()) return [3 /*break*/, 3];
+                        return [4 /*yield*/, 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));
+
+export { PDFObjectStreamParser as default };

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

@@ -0,0 +1,360 @@
+import { __extends, __awaiter, __generator } from '../../../../tslib/tslib.es6.js';
+import PDFCrossRefSection from '../document/PDFCrossRefSection.js';
+import PDFHeader from '../document/PDFHeader.js';
+import PDFTrailer from '../document/PDFTrailer.js';
+import { StalledParserError, ReparseError, MissingPDFHeaderError, MissingKeywordError, PDFInvalidObjectParsingError } from '../errors.js';
+import PDFDict from '../objects/PDFDict.js';
+import PDFInvalidObject from '../objects/PDFInvalidObject.js';
+import PDFName from '../objects/PDFName.js';
+import PDFRawStream from '../objects/PDFRawStream.js';
+import PDFRef from '../objects/PDFRef.js';
+import ByteStream from './ByteStream.js';
+import PDFObjectParser from './PDFObjectParser.js';
+import PDFObjectStreamParser from './PDFObjectStreamParser.js';
+import PDFXRefStreamParser from './PDFXRefStreamParser.js';
+import PDFContext from '../PDFContext.js';
+import CharCodes from '../syntax/CharCodes.js';
+import { Keywords } from '../syntax/Keywords.js';
+import { IsDigit } from '../syntax/Numeric.js';
+import '../../utils/base64.js';
+import { waitForTick } from '../../utils/async.js';
+import '../../utils/unicode.js';
+import '../../utils/objects.js';
+import '../../utils/pdfDocEncoding.js';
+import '../../utils/Cache.js';
+
+var PDFParser = /** @class */ (function (_super) {
+    __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.of(pdfBytes), PDFContext.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 __awaiter(this, void 0, void 0, function () {
+            var prevOffset, offset;
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0:
+                        if (this.alreadyParsed) {
+                            throw new 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 StalledParserError(this.bytes.position());
+                        }
+                        prevOffset = offset;
+                        return [3 /*break*/, 1];
+                    case 3:
+                        this.maybeRecoverRoot();
+                        if (this.context.lookup(PDFRef.of(0))) {
+                            console.warn('Removing parsed object: 0 0 R');
+                            this.context.delete(PDFRef.of(0));
+                        }
+                        return [2 /*return*/, this.context];
+                }
+            });
+        });
+    };
+    PDFParser.prototype.maybeRecoverRoot = function () {
+        var isValidCatalog = function (obj) {
+            return obj instanceof PDFDict &&
+                obj.lookup(PDFName.of('Type')) === PDFName.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.header)) {
+                var major = this.parseRawInt();
+                this.bytes.assertNext(CharCodes.Period);
+                var minor = this.parseRawInt();
+                var header = PDFHeader.forVersion(major, minor);
+                this.skipBinaryHeaderComment();
+                return header;
+            }
+            this.bytes.next();
+        }
+        throw new 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.obj)) {
+            throw new MissingKeywordError(this.bytes.position(), Keywords.obj);
+        }
+        return PDFRef.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 __awaiter(this, void 0, void 0, function () {
+            var ref, object;
+            return __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.endobj);
+                        if (!(object instanceof PDFRawStream &&
+                            object.dict.lookup(PDFName.of('Type')) === PDFName.of('ObjStm'))) return [3 /*break*/, 2];
+                        return [4 /*yield*/, PDFObjectStreamParser.forStream(object, this.shouldWaitForTick).parseIntoContext()];
+                    case 1:
+                        _a.sent();
+                        return [3 /*break*/, 3];
+                    case 2:
+                        if (object instanceof PDFRawStream &&
+                            object.dict.lookup(PDFName.of('Type')) === PDFName.of('XRef')) {
+                            PDFXRefStreamParser.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.endobj)) {
+                failed = false;
+            }
+            if (!failed)
+                break;
+            this.bytes.next();
+        }
+        if (failed)
+            throw new PDFInvalidObjectParsingError(startPos);
+        var end = this.bytes.offset() - Keywords.endobj.length;
+        var object = PDFInvalidObject.of(this.bytes.slice(start, end));
+        this.context.assign(ref, object);
+        return ref;
+    };
+    PDFParser.prototype.parseIndirectObjects = function () {
+        return __awaiter(this, void 0, void 0, function () {
+            var initialOffset;
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0:
+                        this.skipWhitespaceAndComments();
+                        _a.label = 1;
+                    case 1:
+                        if (!(!this.bytes.done() && 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*/, 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.xref))
+            return;
+        this.skipWhitespaceAndComments();
+        var objectNumber = -1;
+        var xref = PDFCrossRefSection.createEmpty();
+        while (!this.bytes.done() && IsDigit[this.bytes.peek()]) {
+            var firstInt = this.parseRawInt();
+            this.skipWhitespaceAndComments();
+            var secondInt = this.parseRawInt();
+            this.skipWhitespaceAndComments();
+            var byte = this.bytes.peek();
+            if (byte === CharCodes.n || byte === CharCodes.f) {
+                var ref = PDFRef.of(objectNumber, secondInt);
+                if (this.bytes.next() === CharCodes.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.trailer))
+            return;
+        this.skipWhitespaceAndComments();
+        var dict = this.parseDict();
+        var context = this.context;
+        context.trailerInfo = {
+            Root: dict.get(PDFName.of('Root')) || context.trailerInfo.Root,
+            Encrypt: dict.get(PDFName.of('Encrypt')) || context.trailerInfo.Encrypt,
+            Info: dict.get(PDFName.of('Info')) || context.trailerInfo.Info,
+            ID: dict.get(PDFName.of('ID')) || context.trailerInfo.ID,
+        };
+    };
+    PDFParser.prototype.maybeParseTrailer = function () {
+        this.skipWhitespaceAndComments();
+        if (!this.matchKeyword(Keywords.startxref))
+            return;
+        this.skipWhitespaceAndComments();
+        var offset = this.parseRawInt();
+        this.skipWhitespace();
+        this.matchKeyword(Keywords.eof);
+        this.skipWhitespaceAndComments();
+        this.matchKeyword(Keywords.eof);
+        this.skipWhitespaceAndComments();
+        return PDFTrailer.forLastCrossRefSectionOffset(offset);
+    };
+    PDFParser.prototype.parseDocumentSection = function () {
+        return __awaiter(this, void 0, void 0, function () {
+            return __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.Space && byte <= CharCodes.Tilde;
+            if (isAlphaNumeric) {
+                if (this.matchKeyword(Keywords.xref) ||
+                    this.matchKeyword(Keywords.trailer) ||
+                    this.matchKeyword(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));
+
+export { PDFParser as default };

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

@@ -0,0 +1,90 @@
+import { ReparseError } from '../errors.js';
+import PDFArray from '../objects/PDFArray.js';
+import PDFName from '../objects/PDFName.js';
+import PDFNumber from '../objects/PDFNumber.js';
+import PDFRef from '../objects/PDFRef.js';
+import ByteStream from './ByteStream.js';
+
+var PDFXRefStreamParser = /** @class */ (function () {
+    function PDFXRefStreamParser(rawStream) {
+        this.alreadyParsed = false;
+        this.dict = rawStream.dict;
+        this.bytes = ByteStream.fromPDFRawStream(rawStream);
+        this.context = this.dict.context;
+        var Size = this.dict.lookup(PDFName.of('Size'), PDFNumber);
+        var Index = this.dict.lookup(PDFName.of('Index'));
+        if (Index instanceof PDFArray) {
+            this.subsections = [];
+            for (var idx = 0, len = Index.size(); idx < len; idx += 2) {
+                var firstObjectNumber = Index.lookup(idx + 0, PDFNumber).asNumber();
+                var length_1 = Index.lookup(idx + 1, PDFNumber).asNumber();
+                this.subsections.push({ firstObjectNumber: firstObjectNumber, length: length_1 });
+            }
+        }
+        else {
+            this.subsections = [{ firstObjectNumber: 0, length: Size.asNumber() }];
+        }
+        var W = this.dict.lookup(PDFName.of('W'), PDFArray);
+        this.byteWidths = [-1, -1, -1];
+        for (var idx = 0, len = W.size(); idx < len; idx++) {
+            this.byteWidths[idx] = W.lookup(idx, PDFNumber).asNumber();
+        }
+    }
+    PDFXRefStreamParser.prototype.parseIntoContext = function () {
+        if (this.alreadyParsed) {
+            throw new ReparseError('PDFXRefStreamParser', 'parseIntoContext');
+        }
+        this.alreadyParsed = true;
+        this.context.trailerInfo = {
+            Root: this.dict.get(PDFName.of('Root')),
+            Encrypt: this.dict.get(PDFName.of('Encrypt')),
+            Info: this.dict.get(PDFName.of('Info')),
+            ID: this.dict.get(PDFName.of('ID')),
+        };
+        var entries = this.parseEntries();
+        // for (let idx = 0, len = entries.length; idx < len; idx++) {
+        // const entry = entries[idx];
+        // if (entry.deleted) this.context.delete(entry.ref);
+        // }
+        return entries;
+    };
+    PDFXRefStreamParser.prototype.parseEntries = function () {
+        var entries = [];
+        var _a = this.byteWidths, typeFieldWidth = _a[0], offsetFieldWidth = _a[1], genFieldWidth = _a[2];
+        for (var subsectionIdx = 0, subsectionLen = this.subsections.length; subsectionIdx < subsectionLen; subsectionIdx++) {
+            var _b = this.subsections[subsectionIdx], firstObjectNumber = _b.firstObjectNumber, length_2 = _b.length;
+            for (var objIdx = 0; objIdx < length_2; objIdx++) {
+                var type = 0;
+                for (var idx = 0, len = typeFieldWidth; idx < len; idx++) {
+                    type = (type << 8) | this.bytes.next();
+                }
+                var offset = 0;
+                for (var idx = 0, len = offsetFieldWidth; idx < len; idx++) {
+                    offset = (offset << 8) | this.bytes.next();
+                }
+                var generationNumber = 0;
+                for (var idx = 0, len = genFieldWidth; idx < len; idx++) {
+                    generationNumber = (generationNumber << 8) | this.bytes.next();
+                }
+                // When the `type` field is absent, it defaults to 1
+                if (typeFieldWidth === 0)
+                    type = 1;
+                var objectNumber = firstObjectNumber + objIdx;
+                var entry = {
+                    ref: PDFRef.of(objectNumber, generationNumber),
+                    offset: offset,
+                    deleted: type === 0,
+                    inObjectStream: type === 2,
+                };
+                entries.push(entry);
+            }
+        }
+        return entries;
+    };
+    PDFXRefStreamParser.forStream = function (rawStream) {
+        return new PDFXRefStreamParser(rawStream);
+    };
+    return PDFXRefStreamParser;
+}());
+
+export { PDFXRefStreamParser as default };

package/dist/esm/node_modules/pdf-lib/es/core/streams/Ascii85Stream.js

@@ -0,0 +1,86 @@
+import { __extends } from '../../../../tslib/tslib.es6.js';
+import DecodeStream from './DecodeStream.js';
+
+/*
+ * Copyright 2012 Mozilla Foundation
+ *
+ * The Ascii85Stream class contained in this file is a TypeScript port of the
+ * JavaScript Ascii85Stream class in Mozilla's pdf.js project, made available
+ * under the Apache 2.0 open source license.
+ */
+var isSpace = function (ch) {
+    return ch === 0x20 || ch === 0x09 || ch === 0x0d || ch === 0x0a;
+};
+var Ascii85Stream = /** @class */ (function (_super) {
+    __extends(Ascii85Stream, _super);
+    function Ascii85Stream(stream, maybeLength) {
+        var _this = _super.call(this, maybeLength) || this;
+        _this.stream = stream;
+        _this.input = new Uint8Array(5);
+        // Most streams increase in size when decoded, but Ascii85 streams
+        // typically shrink by ~20%.
+        if (maybeLength) {
+            maybeLength = 0.8 * maybeLength;
+        }
+        return _this;
+    }
+    Ascii85Stream.prototype.readBlock = function () {
+        var TILDA_CHAR = 0x7e; // '~'
+        var Z_LOWER_CHAR = 0x7a; // 'z'
+        var EOF = -1;
+        var stream = this.stream;
+        var c = stream.getByte();
+        while (isSpace(c)) {
+            c = stream.getByte();
+        }
+        if (c === EOF || c === TILDA_CHAR) {
+            this.eof = true;
+            return;
+        }
+        var bufferLength = this.bufferLength;
+        var buffer;
+        var i;
+        // special code for z
+        if (c === Z_LOWER_CHAR) {
+            buffer = this.ensureBuffer(bufferLength + 4);
+            for (i = 0; i < 4; ++i) {
+                buffer[bufferLength + i] = 0;
+            }
+            this.bufferLength += 4;
+        }
+        else {
+            var input = this.input;
+            input[0] = c;
+            for (i = 1; i < 5; ++i) {
+                c = stream.getByte();
+                while (isSpace(c)) {
+                    c = stream.getByte();
+                }
+                input[i] = c;
+                if (c === EOF || c === TILDA_CHAR) {
+                    break;
+                }
+            }
+            buffer = this.ensureBuffer(bufferLength + i - 1);
+            this.bufferLength += i - 1;
+            // partial ending;
+            if (i < 5) {
+                for (; i < 5; ++i) {
+                    input[i] = 0x21 + 84;
+                }
+                this.eof = true;
+            }
+            var t = 0;
+            for (i = 0; i < 5; ++i) {
+                t = t * 85 + (input[i] - 0x21);
+            }
+            for (i = 3; i >= 0; --i) {
+                buffer[bufferLength + i] = t & 0xff;
+                t >>= 8;
+            }
+        }
+    };
+    return Ascii85Stream;
+}(DecodeStream));
+
+export { Ascii85Stream as default };

package/dist/esm/node_modules/pdf-lib/es/core/streams/AsciiHexStream.js

@@ -0,0 +1,74 @@
+import { __extends } from '../../../../tslib/tslib.es6.js';
+import DecodeStream from './DecodeStream.js';
+
+/*
+ * Copyright 2012 Mozilla Foundation
+ *
+ * The AsciiHexStream class contained in this file is a TypeScript port of the
+ * JavaScript AsciiHexStream class in Mozilla's pdf.js project, made available
+ * under the Apache 2.0 open source license.
+ */
+var AsciiHexStream = /** @class */ (function (_super) {
+    __extends(AsciiHexStream, _super);
+    function AsciiHexStream(stream, maybeLength) {
+        var _this = _super.call(this, maybeLength) || this;
+        _this.stream = stream;
+        _this.firstDigit = -1;
+        // Most streams increase in size when decoded, but AsciiHex streams shrink
+        // by 50%.
+        if (maybeLength) {
+            maybeLength = 0.5 * maybeLength;
+        }
+        return _this;
+    }
+    AsciiHexStream.prototype.readBlock = function () {
+        var UPSTREAM_BLOCK_SIZE = 8000;
+        var bytes = this.stream.getBytes(UPSTREAM_BLOCK_SIZE);
+        if (!bytes.length) {
+            this.eof = true;
+            return;
+        }
+        var maxDecodeLength = (bytes.length + 1) >> 1;
+        var buffer = this.ensureBuffer(this.bufferLength + maxDecodeLength);
+        var bufferLength = this.bufferLength;
+        var firstDigit = this.firstDigit;
+        for (var i = 0, ii = bytes.length; i < ii; i++) {
+            var ch = bytes[i];
+            var digit = void 0;
+            if (ch >= 0x30 && ch <= 0x39) {
+                // '0'-'9'
+                digit = ch & 0x0f;
+            }
+            else if ((ch >= 0x41 && ch <= 0x46) || (ch >= 0x61 && ch <= 0x66)) {
+                // 'A'-'Z', 'a'-'z'
+                digit = (ch & 0x0f) + 9;
+            }
+            else if (ch === 0x3e) {
+                // '>'
+                this.eof = true;
+                break;
+            }
+            else {
+                // probably whitespace
+                continue; // ignoring
+            }
+            if (firstDigit < 0) {
+                firstDigit = digit;
+            }
+            else {
+                buffer[bufferLength++] = (firstDigit << 4) | digit;
+                firstDigit = -1;
+            }
+        }
+        if (firstDigit >= 0 && this.eof) {
+            // incomplete byte
+            buffer[bufferLength++] = firstDigit << 4;
+            firstDigit = -1;
+        }
+        this.firstDigit = firstDigit;
+        this.bufferLength = bufferLength;
+    };
+    return AsciiHexStream;
+}(DecodeStream));
+
+export { AsciiHexStream as default };