art-bd-ui 1.0.21 → 1.0.23

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

@@ -0,0 +1,54 @@
+import { __extends } from '../../../../tslib/tslib.es6.js';
+import DecodeStream from './DecodeStream.js';
+
+/*
+ * Copyright 2012 Mozilla Foundation
+ *
+ * The RunLengthStream class contained in this file is a TypeScript port of the
+ * JavaScript RunLengthStream class in Mozilla's pdf.js project, made available
+ * under the Apache 2.0 open source license.
+ */
+var RunLengthStream = /** @class */ (function (_super) {
+    __extends(RunLengthStream, _super);
+    function RunLengthStream(stream, maybeLength) {
+        var _this = _super.call(this, maybeLength) || this;
+        _this.stream = stream;
+        return _this;
+    }
+    RunLengthStream.prototype.readBlock = function () {
+        // The repeatHeader has following format. The first byte defines type of run
+        // and amount of bytes to repeat/copy: n = 0 through 127 - copy next n bytes
+        // (in addition to the second byte from the header), n = 129 through 255 -
+        // duplicate the second byte from the header (257 - n) times, n = 128 - end.
+        var repeatHeader = this.stream.getBytes(2);
+        if (!repeatHeader || repeatHeader.length < 2 || repeatHeader[0] === 128) {
+            this.eof = true;
+            return;
+        }
+        var buffer;
+        var bufferLength = this.bufferLength;
+        var n = repeatHeader[0];
+        if (n < 128) {
+            // copy n bytes
+            buffer = this.ensureBuffer(bufferLength + n + 1);
+            buffer[bufferLength++] = repeatHeader[1];
+            if (n > 0) {
+                var source = this.stream.getBytes(n);
+                buffer.set(source, bufferLength);
+                bufferLength += n;
+            }
+        }
+        else {
+            n = 257 - n;
+            var b = repeatHeader[1];
+            buffer = this.ensureBuffer(bufferLength + n + 1);
+            for (var i = 0; i < n; i++) {
+                buffer[bufferLength++] = b;
+            }
+        }
+        this.bufferLength = bufferLength;
+    };
+    return RunLengthStream;
+}(DecodeStream));
+
+export { RunLengthStream as default };

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

@@ -0,0 +1,104 @@
+/*
+ * Copyright 2012 Mozilla Foundation
+ *
+ * The Stream class contained in this file is a TypeScript port of the
+ * JavaScript Stream class in Mozilla's pdf.js project, made available
+ * under the Apache 2.0 open source license.
+ */
+var Stream = /** @class */ (function () {
+    function Stream(buffer, start, length) {
+        this.bytes = buffer;
+        this.start = start || 0;
+        this.pos = this.start;
+        this.end = !!start && !!length ? start + length : this.bytes.length;
+    }
+    Object.defineProperty(Stream.prototype, "length", {
+        get: function () {
+            return this.end - this.start;
+        },
+        enumerable: false,
+        configurable: true
+    });
+    Object.defineProperty(Stream.prototype, "isEmpty", {
+        get: function () {
+            return this.length === 0;
+        },
+        enumerable: false,
+        configurable: true
+    });
+    Stream.prototype.getByte = function () {
+        if (this.pos >= this.end) {
+            return -1;
+        }
+        return this.bytes[this.pos++];
+    };
+    Stream.prototype.getUint16 = function () {
+        var b0 = this.getByte();
+        var b1 = this.getByte();
+        if (b0 === -1 || b1 === -1) {
+            return -1;
+        }
+        return (b0 << 8) + b1;
+    };
+    Stream.prototype.getInt32 = function () {
+        var b0 = this.getByte();
+        var b1 = this.getByte();
+        var b2 = this.getByte();
+        var b3 = this.getByte();
+        return (b0 << 24) + (b1 << 16) + (b2 << 8) + b3;
+    };
+    // Returns subarray of original buffer, should only be read.
+    Stream.prototype.getBytes = function (length, forceClamped) {
+        if (forceClamped === void 0) { forceClamped = false; }
+        var bytes = this.bytes;
+        var pos = this.pos;
+        var strEnd = this.end;
+        if (!length) {
+            var subarray = bytes.subarray(pos, strEnd);
+            // `this.bytes` is always a `Uint8Array` here.
+            return forceClamped ? new Uint8ClampedArray(subarray) : subarray;
+        }
+        else {
+            var end = pos + length;
+            if (end > strEnd) {
+                end = strEnd;
+            }
+            this.pos = end;
+            var subarray = bytes.subarray(pos, end);
+            // `this.bytes` is always a `Uint8Array` here.
+            return forceClamped ? new Uint8ClampedArray(subarray) : subarray;
+        }
+    };
+    Stream.prototype.peekByte = function () {
+        var peekedByte = this.getByte();
+        this.pos--;
+        return peekedByte;
+    };
+    Stream.prototype.peekBytes = function (length, forceClamped) {
+        if (forceClamped === void 0) { forceClamped = false; }
+        var bytes = this.getBytes(length, forceClamped);
+        this.pos -= bytes.length;
+        return bytes;
+    };
+    Stream.prototype.skip = function (n) {
+        if (!n) {
+            n = 1;
+        }
+        this.pos += n;
+    };
+    Stream.prototype.reset = function () {
+        this.pos = this.start;
+    };
+    Stream.prototype.moveStart = function () {
+        this.start = this.pos;
+    };
+    Stream.prototype.makeSubStream = function (start, length) {
+        return new Stream(this.bytes, start, length);
+    };
+    Stream.prototype.decode = function () {
+        return this.bytes;
+    };
+    return Stream;
+}());
+
+export { Stream as default };

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

@@ -0,0 +1,57 @@
+import { UnexpectedObjectTypeError, UnsupportedEncodingError } from '../errors.js';
+import PDFArray from '../objects/PDFArray.js';
+import PDFDict from '../objects/PDFDict.js';
+import PDFName from '../objects/PDFName.js';
+import PDFNumber from '../objects/PDFNumber.js';
+import Ascii85Stream from './Ascii85Stream.js';
+import AsciiHexStream from './AsciiHexStream.js';
+import FlateStream from './FlateStream.js';
+import LZWStream from './LZWStream.js';
+import RunLengthStream from './RunLengthStream.js';
+import Stream from './Stream.js';
+
+var decodeStream = function (stream, encoding, params) {
+    if (encoding === PDFName.of('FlateDecode')) {
+        return new FlateStream(stream);
+    }
+    if (encoding === PDFName.of('LZWDecode')) {
+        var earlyChange = 1;
+        if (params instanceof PDFDict) {
+            var EarlyChange = params.lookup(PDFName.of('EarlyChange'));
+            if (EarlyChange instanceof PDFNumber) {
+                earlyChange = EarlyChange.asNumber();
+            }
+        }
+        return new LZWStream(stream, undefined, earlyChange);
+    }
+    if (encoding === PDFName.of('ASCII85Decode')) {
+        return new Ascii85Stream(stream);
+    }
+    if (encoding === PDFName.of('ASCIIHexDecode')) {
+        return new AsciiHexStream(stream);
+    }
+    if (encoding === PDFName.of('RunLengthDecode')) {
+        return new RunLengthStream(stream);
+    }
+    throw new UnsupportedEncodingError(encoding.asString());
+};
+var decodePDFRawStream = function (_a) {
+    var dict = _a.dict, contents = _a.contents;
+    var stream = new Stream(contents);
+    var Filter = dict.lookup(PDFName.of('Filter'));
+    var DecodeParms = dict.lookup(PDFName.of('DecodeParms'));
+    if (Filter instanceof PDFName) {
+        stream = decodeStream(stream, Filter, DecodeParms);
+    }
+    else if (Filter instanceof PDFArray) {
+        for (var idx = 0, len = Filter.size(); idx < len; idx++) {
+            stream = decodeStream(stream, Filter.lookup(idx, PDFName), DecodeParms && DecodeParms.lookupMaybe(idx, PDFDict));
+        }
+    }
+    else if (!!Filter) {
+        throw new UnexpectedObjectTypeError([PDFName, PDFArray], Filter);
+    }
+    return stream;
+};
+
+export { decodePDFRawStream };

package/dist/esm/node_modules/pdf-lib/es/core/structures/PDFCatalog.js

@@ -0,0 +1,94 @@
+import { __extends } from '../../../../tslib/tslib.es6.js';
+import PDFDict from '../objects/PDFDict.js';
+import PDFName from '../objects/PDFName.js';
+import '../acroform/PDFAcroButton.js';
+import '../acroform/PDFAcroCheckBox.js';
+import '../acroform/PDFAcroChoice.js';
+import '../acroform/PDFAcroComboBox.js';
+import '../acroform/PDFAcroField.js';
+import PDFAcroForm from '../acroform/PDFAcroForm.js';
+import '../acroform/PDFAcroListBox.js';
+import '../acroform/PDFAcroNonTerminal.js';
+import '../acroform/PDFAcroPushButton.js';
+import '../acroform/PDFAcroRadioButton.js';
+import '../acroform/PDFAcroSignature.js';
+import '../acroform/PDFAcroTerminal.js';
+import '../acroform/PDFAcroText.js';
+import '../acroform/flags.js';
+import '../objects/PDFNumber.js';
+import '../objects/PDFArray.js';
+import '../objects/PDFRef.js';
+import ViewerPreferences from '../interactive/ViewerPreferences.js';
+
+var PDFCatalog = /** @class */ (function (_super) {
+    __extends(PDFCatalog, _super);
+    function PDFCatalog() {
+        return _super !== null && _super.apply(this, arguments) || this;
+    }
+    PDFCatalog.prototype.Pages = function () {
+        return this.lookup(PDFName.of('Pages'), PDFDict);
+    };
+    PDFCatalog.prototype.AcroForm = function () {
+        return this.lookupMaybe(PDFName.of('AcroForm'), PDFDict);
+    };
+    PDFCatalog.prototype.getAcroForm = function () {
+        var dict = this.AcroForm();
+        if (!dict)
+            return undefined;
+        return PDFAcroForm.fromDict(dict);
+    };
+    PDFCatalog.prototype.getOrCreateAcroForm = function () {
+        var acroForm = this.getAcroForm();
+        if (!acroForm) {
+            acroForm = PDFAcroForm.create(this.context);
+            var acroFormRef = this.context.register(acroForm.dict);
+            this.set(PDFName.of('AcroForm'), acroFormRef);
+        }
+        return acroForm;
+    };
+    PDFCatalog.prototype.ViewerPreferences = function () {
+        return this.lookupMaybe(PDFName.of('ViewerPreferences'), PDFDict);
+    };
+    PDFCatalog.prototype.getViewerPreferences = function () {
+        var dict = this.ViewerPreferences();
+        if (!dict)
+            return undefined;
+        return ViewerPreferences.fromDict(dict);
+    };
+    PDFCatalog.prototype.getOrCreateViewerPreferences = function () {
+        var viewerPrefs = this.getViewerPreferences();
+        if (!viewerPrefs) {
+            viewerPrefs = ViewerPreferences.create(this.context);
+            var viewerPrefsRef = this.context.register(viewerPrefs.dict);
+            this.set(PDFName.of('ViewerPreferences'), viewerPrefsRef);
+        }
+        return viewerPrefs;
+    };
+    /**
+     * Inserts the given ref as a leaf node of this catalog's page tree at the
+     * specified index (zero-based). Also increments the `Count` of each node in
+     * the page tree hierarchy to accomodate the new page.
+     *
+     * Returns the ref of the PDFPageTree node into which `leafRef` was inserted.
+     */
+    PDFCatalog.prototype.insertLeafNode = function (leafRef, index) {
+        var pagesRef = this.get(PDFName.of('Pages'));
+        var maybeParentRef = this.Pages().insertLeafNode(leafRef, index);
+        return maybeParentRef || pagesRef;
+    };
+    PDFCatalog.prototype.removeLeafNode = function (index) {
+        this.Pages().removeLeafNode(index);
+    };
+    PDFCatalog.withContextAndPages = function (context, pages) {
+        var dict = new Map();
+        dict.set(PDFName.of('Type'), PDFName.of('Catalog'));
+        dict.set(PDFName.of('Pages'), pages);
+        return new PDFCatalog(dict, context);
+    };
+    PDFCatalog.fromMapWithContext = function (map, context) {
+        return new PDFCatalog(map, context);
+    };
+    return PDFCatalog;
+}(PDFDict));
+
+export { PDFCatalog as default };

package/dist/esm/node_modules/pdf-lib/es/core/structures/PDFContentStream.js

@@ -0,0 +1,59 @@
+import { __extends } from '../../../../tslib/tslib.es6.js';
+import PDFFlateStream from './PDFFlateStream.js';
+import CharCodes from '../syntax/CharCodes.js';
+
+var PDFContentStream = /** @class */ (function (_super) {
+    __extends(PDFContentStream, _super);
+    function PDFContentStream(dict, operators, encode) {
+        if (encode === void 0) { encode = true; }
+        var _this = _super.call(this, dict, encode) || this;
+        _this.operators = operators;
+        return _this;
+    }
+    PDFContentStream.prototype.push = function () {
+        var _a;
+        var operators = [];
+        for (var _i = 0; _i < arguments.length; _i++) {
+            operators[_i] = arguments[_i];
+        }
+        (_a = this.operators).push.apply(_a, operators);
+    };
+    PDFContentStream.prototype.clone = function (context) {
+        var operators = new Array(this.operators.length);
+        for (var idx = 0, len = this.operators.length; idx < len; idx++) {
+            operators[idx] = this.operators[idx].clone(context);
+        }
+        var _a = this, dict = _a.dict, encode = _a.encode;
+        return PDFContentStream.of(dict.clone(context), operators, encode);
+    };
+    PDFContentStream.prototype.getContentsString = function () {
+        var value = '';
+        for (var idx = 0, len = this.operators.length; idx < len; idx++) {
+            value += this.operators[idx] + "\n";
+        }
+        return value;
+    };
+    PDFContentStream.prototype.getUnencodedContents = function () {
+        var buffer = new Uint8Array(this.getUnencodedContentsSize());
+        var offset = 0;
+        for (var idx = 0, len = this.operators.length; idx < len; idx++) {
+            offset += this.operators[idx].copyBytesInto(buffer, offset);
+            buffer[offset++] = CharCodes.Newline;
+        }
+        return buffer;
+    };
+    PDFContentStream.prototype.getUnencodedContentsSize = function () {
+        var size = 0;
+        for (var idx = 0, len = this.operators.length; idx < len; idx++) {
+            size += this.operators[idx].sizeInBytes() + 1;
+        }
+        return size;
+    };
+    PDFContentStream.of = function (dict, operators, encode) {
+        if (encode === void 0) { encode = true; }
+        return new PDFContentStream(dict, operators, encode);
+    };
+    return PDFContentStream;
+}(PDFFlateStream));
+
+export { PDFContentStream as default };

package/dist/esm/node_modules/pdf-lib/es/core/structures/PDFCrossRefStream.js

@@ -0,0 +1,191 @@
+import { __extends } from '../../../../tslib/tslib.es6.js';
+import PDFName from '../objects/PDFName.js';
+import PDFRef from '../objects/PDFRef.js';
+import PDFFlateStream from './PDFFlateStream.js';
+import { reverseArray, sum } from '../../utils/arrays.js';
+import '../../utils/unicode.js';
+import { sizeInBytes, bytesFor } from '../../utils/numbers.js';
+import '../../utils/base64.js';
+import '../../utils/objects.js';
+import '../../utils/pdfDocEncoding.js';
+import Cache from '../../utils/Cache.js';
+
+var EntryType;
+(function (EntryType) {
+    EntryType[EntryType["Deleted"] = 0] = "Deleted";
+    EntryType[EntryType["Uncompressed"] = 1] = "Uncompressed";
+    EntryType[EntryType["Compressed"] = 2] = "Compressed";
+})(EntryType || (EntryType = {}));
+/**
+ * Entries should be added using the [[addDeletedEntry]],
+ * [[addUncompressedEntry]], and [[addCompressedEntry]] methods
+ * **in order of ascending object number**.
+ */
+var PDFCrossRefStream = /** @class */ (function (_super) {
+    __extends(PDFCrossRefStream, _super);
+    function PDFCrossRefStream(dict, entries, encode) {
+        if (encode === void 0) { encode = true; }
+        var _this = _super.call(this, dict, encode) || this;
+        // Returns an array of integer pairs for each subsection of the cross ref
+        // section, where each integer pair represents:
+        //   firstObjectNumber(OfSection), length(OfSection)
+        _this.computeIndex = function () {
+            var subsections = [];
+            var subsectionLength = 0;
+            for (var idx = 0, len = _this.entries.length; idx < len; idx++) {
+                var currEntry = _this.entries[idx];
+                var prevEntry = _this.entries[idx - 1];
+                if (idx === 0) {
+                    subsections.push(currEntry.ref.objectNumber);
+                }
+                else if (currEntry.ref.objectNumber - prevEntry.ref.objectNumber > 1) {
+                    subsections.push(subsectionLength);
+                    subsections.push(currEntry.ref.objectNumber);
+                    subsectionLength = 0;
+                }
+                subsectionLength += 1;
+            }
+            subsections.push(subsectionLength);
+            return subsections;
+        };
+        _this.computeEntryTuples = function () {
+            var entryTuples = new Array(_this.entries.length);
+            for (var idx = 0, len = _this.entries.length; idx < len; idx++) {
+                var entry = _this.entries[idx];
+                if (entry.type === EntryType.Deleted) {
+                    var type = entry.type, nextFreeObjectNumber = entry.nextFreeObjectNumber, ref = entry.ref;
+                    entryTuples[idx] = [type, nextFreeObjectNumber, ref.generationNumber];
+                }
+                if (entry.type === EntryType.Uncompressed) {
+                    var type = entry.type, offset = entry.offset, ref = entry.ref;
+                    entryTuples[idx] = [type, offset, ref.generationNumber];
+                }
+                if (entry.type === EntryType.Compressed) {
+                    var type = entry.type, objectStreamRef = entry.objectStreamRef, index = entry.index;
+                    entryTuples[idx] = [type, objectStreamRef.objectNumber, index];
+                }
+            }
+            return entryTuples;
+        };
+        _this.computeMaxEntryByteWidths = function () {
+            var entryTuples = _this.entryTuplesCache.access();
+            var widths = [0, 0, 0];
+            for (var idx = 0, len = entryTuples.length; idx < len; idx++) {
+                var _a = entryTuples[idx], first = _a[0], second = _a[1], third = _a[2];
+                var firstSize = sizeInBytes(first);
+                var secondSize = sizeInBytes(second);
+                var thirdSize = sizeInBytes(third);
+                if (firstSize > widths[0])
+                    widths[0] = firstSize;
+                if (secondSize > widths[1])
+                    widths[1] = secondSize;
+                if (thirdSize > widths[2])
+                    widths[2] = thirdSize;
+            }
+            return widths;
+        };
+        _this.entries = entries || [];
+        _this.entryTuplesCache = Cache.populatedBy(_this.computeEntryTuples);
+        _this.maxByteWidthsCache = Cache.populatedBy(_this.computeMaxEntryByteWidths);
+        _this.indexCache = Cache.populatedBy(_this.computeIndex);
+        dict.set(PDFName.of('Type'), PDFName.of('XRef'));
+        return _this;
+    }
+    PDFCrossRefStream.prototype.addDeletedEntry = function (ref, nextFreeObjectNumber) {
+        var type = EntryType.Deleted;
+        this.entries.push({ type: type, ref: ref, nextFreeObjectNumber: nextFreeObjectNumber });
+        this.entryTuplesCache.invalidate();
+        this.maxByteWidthsCache.invalidate();
+        this.indexCache.invalidate();
+        this.contentsCache.invalidate();
+    };
+    PDFCrossRefStream.prototype.addUncompressedEntry = function (ref, offset) {
+        var type = EntryType.Uncompressed;
+        this.entries.push({ type: type, ref: ref, offset: offset });
+        this.entryTuplesCache.invalidate();
+        this.maxByteWidthsCache.invalidate();
+        this.indexCache.invalidate();
+        this.contentsCache.invalidate();
+    };
+    PDFCrossRefStream.prototype.addCompressedEntry = function (ref, objectStreamRef, index) {
+        var type = EntryType.Compressed;
+        this.entries.push({ type: type, ref: ref, objectStreamRef: objectStreamRef, index: index });
+        this.entryTuplesCache.invalidate();
+        this.maxByteWidthsCache.invalidate();
+        this.indexCache.invalidate();
+        this.contentsCache.invalidate();
+    };
+    PDFCrossRefStream.prototype.clone = function (context) {
+        var _a = this, dict = _a.dict, entries = _a.entries, encode = _a.encode;
+        return PDFCrossRefStream.of(dict.clone(context), entries.slice(), encode);
+    };
+    PDFCrossRefStream.prototype.getContentsString = function () {
+        var entryTuples = this.entryTuplesCache.access();
+        var byteWidths = this.maxByteWidthsCache.access();
+        var value = '';
+        for (var entryIdx = 0, entriesLen = entryTuples.length; entryIdx < entriesLen; entryIdx++) {
+            var _a = entryTuples[entryIdx], first = _a[0], second = _a[1], third = _a[2];
+            var firstBytes = reverseArray(bytesFor(first));
+            var secondBytes = reverseArray(bytesFor(second));
+            var thirdBytes = reverseArray(bytesFor(third));
+            for (var idx = byteWidths[0] - 1; idx >= 0; idx--) {
+                value += (firstBytes[idx] || 0).toString(2);
+            }
+            for (var idx = byteWidths[1] - 1; idx >= 0; idx--) {
+                value += (secondBytes[idx] || 0).toString(2);
+            }
+            for (var idx = byteWidths[2] - 1; idx >= 0; idx--) {
+                value += (thirdBytes[idx] || 0).toString(2);
+            }
+        }
+        return value;
+    };
+    PDFCrossRefStream.prototype.getUnencodedContents = function () {
+        var entryTuples = this.entryTuplesCache.access();
+        var byteWidths = this.maxByteWidthsCache.access();
+        var buffer = new Uint8Array(this.getUnencodedContentsSize());
+        var offset = 0;
+        for (var entryIdx = 0, entriesLen = entryTuples.length; entryIdx < entriesLen; entryIdx++) {
+            var _a = entryTuples[entryIdx], first = _a[0], second = _a[1], third = _a[2];
+            var firstBytes = reverseArray(bytesFor(first));
+            var secondBytes = reverseArray(bytesFor(second));
+            var thirdBytes = reverseArray(bytesFor(third));
+            for (var idx = byteWidths[0] - 1; idx >= 0; idx--) {
+                buffer[offset++] = firstBytes[idx] || 0;
+            }
+            for (var idx = byteWidths[1] - 1; idx >= 0; idx--) {
+                buffer[offset++] = secondBytes[idx] || 0;
+            }
+            for (var idx = byteWidths[2] - 1; idx >= 0; idx--) {
+                buffer[offset++] = thirdBytes[idx] || 0;
+            }
+        }
+        return buffer;
+    };
+    PDFCrossRefStream.prototype.getUnencodedContentsSize = function () {
+        var byteWidths = this.maxByteWidthsCache.access();
+        var entryWidth = sum(byteWidths);
+        return entryWidth * this.entries.length;
+    };
+    PDFCrossRefStream.prototype.updateDict = function () {
+        _super.prototype.updateDict.call(this);
+        var byteWidths = this.maxByteWidthsCache.access();
+        var index = this.indexCache.access();
+        var context = this.dict.context;
+        this.dict.set(PDFName.of('W'), context.obj(byteWidths));
+        this.dict.set(PDFName.of('Index'), context.obj(index));
+    };
+    PDFCrossRefStream.create = function (dict, encode) {
+        if (encode === void 0) { encode = true; }
+        var stream = new PDFCrossRefStream(dict, [], encode);
+        stream.addDeletedEntry(PDFRef.of(0, 65535), 0);
+        return stream;
+    };
+    PDFCrossRefStream.of = function (dict, entries, encode) {
+        if (encode === void 0) { encode = true; }
+        return new PDFCrossRefStream(dict, entries, encode);
+    };
+    return PDFCrossRefStream;
+}(PDFFlateStream));
+
+export { EntryType, PDFCrossRefStream as default };

package/dist/esm/node_modules/pdf-lib/es/core/structures/PDFFlateStream.js

@@ -0,0 +1,38 @@
+import { __extends } from '../../../../tslib/tslib.es6.js';
+import pako from '../../../../../_virtual/index8.js';
+import { MethodNotImplementedError } from '../errors.js';
+import PDFName from '../objects/PDFName.js';
+import PDFStream from '../objects/PDFStream.js';
+import '../../utils/base64.js';
+import '../../utils/unicode.js';
+import '../../utils/objects.js';
+import '../../utils/pdfDocEncoding.js';
+import Cache from '../../utils/Cache.js';
+
+var PDFFlateStream = /** @class */ (function (_super) {
+    __extends(PDFFlateStream, _super);
+    function PDFFlateStream(dict, encode) {
+        var _this = _super.call(this, dict) || this;
+        _this.computeContents = function () {
+            var unencodedContents = _this.getUnencodedContents();
+            return _this.encode ? pako.deflate(unencodedContents) : unencodedContents;
+        };
+        _this.encode = encode;
+        if (encode)
+            dict.set(PDFName.of('Filter'), PDFName.of('FlateDecode'));
+        _this.contentsCache = Cache.populatedBy(_this.computeContents);
+        return _this;
+    }
+    PDFFlateStream.prototype.getContents = function () {
+        return this.contentsCache.access();
+    };
+    PDFFlateStream.prototype.getContentsSize = function () {
+        return this.contentsCache.access().length;
+    };
+    PDFFlateStream.prototype.getUnencodedContents = function () {
+        throw new MethodNotImplementedError(this.constructor.name, 'getUnencodedContents');
+    };
+    return PDFFlateStream;
+}(PDFStream));
+
+export { PDFFlateStream as default };

package/dist/esm/node_modules/pdf-lib/es/core/structures/PDFObjectStream.js

@@ -0,0 +1,82 @@
+import { __extends } from '../../../../tslib/tslib.es6.js';
+import PDFName from '../objects/PDFName.js';
+import PDFNumber from '../objects/PDFNumber.js';
+import PDFFlateStream from './PDFFlateStream.js';
+import CharCodes from '../syntax/CharCodes.js';
+import { last } from '../../utils/arrays.js';
+import { copyStringIntoBuffer } from '../../utils/strings.js';
+import '../../utils/unicode.js';
+import '../../utils/base64.js';
+import '../../utils/objects.js';
+import '../../utils/pdfDocEncoding.js';
+import '../../utils/Cache.js';
+
+var PDFObjectStream = /** @class */ (function (_super) {
+    __extends(PDFObjectStream, _super);
+    function PDFObjectStream(context, objects, encode) {
+        if (encode === void 0) { encode = true; }
+        var _this = _super.call(this, context.obj({}), encode) || this;
+        _this.objects = objects;
+        _this.offsets = _this.computeObjectOffsets();
+        _this.offsetsString = _this.computeOffsetsString();
+        _this.dict.set(PDFName.of('Type'), PDFName.of('ObjStm'));
+        _this.dict.set(PDFName.of('N'), PDFNumber.of(_this.objects.length));
+        _this.dict.set(PDFName.of('First'), PDFNumber.of(_this.offsetsString.length));
+        return _this;
+    }
+    PDFObjectStream.prototype.getObjectsCount = function () {
+        return this.objects.length;
+    };
+    PDFObjectStream.prototype.clone = function (context) {
+        return PDFObjectStream.withContextAndObjects(context || this.dict.context, this.objects.slice(), this.encode);
+    };
+    PDFObjectStream.prototype.getContentsString = function () {
+        var value = this.offsetsString;
+        for (var idx = 0, len = this.objects.length; idx < len; idx++) {
+            var _a = this.objects[idx], object = _a[1];
+            value += object + "\n";
+        }
+        return value;
+    };
+    PDFObjectStream.prototype.getUnencodedContents = function () {
+        var buffer = new Uint8Array(this.getUnencodedContentsSize());
+        var offset = copyStringIntoBuffer(this.offsetsString, buffer, 0);
+        for (var idx = 0, len = this.objects.length; idx < len; idx++) {
+            var _a = this.objects[idx], object = _a[1];
+            offset += object.copyBytesInto(buffer, offset);
+            buffer[offset++] = CharCodes.Newline;
+        }
+        return buffer;
+    };
+    PDFObjectStream.prototype.getUnencodedContentsSize = function () {
+        return (this.offsetsString.length +
+            last(this.offsets)[1] +
+            last(this.objects)[1].sizeInBytes() +
+            1);
+    };
+    PDFObjectStream.prototype.computeOffsetsString = function () {
+        var offsetsString = '';
+        for (var idx = 0, len = this.offsets.length; idx < len; idx++) {
+            var _a = this.offsets[idx], objectNumber = _a[0], offset = _a[1];
+            offsetsString += objectNumber + " " + offset + " ";
+        }
+        return offsetsString;
+    };
+    PDFObjectStream.prototype.computeObjectOffsets = function () {
+        var offset = 0;
+        var offsets = new Array(this.objects.length);
+        for (var idx = 0, len = this.objects.length; idx < len; idx++) {
+            var _a = this.objects[idx], ref = _a[0], object = _a[1];
+            offsets[idx] = [ref.objectNumber, offset];
+            offset += object.sizeInBytes() + 1; // '\n'
+        }
+        return offsets;
+    };
+    PDFObjectStream.withContextAndObjects = function (context, objects, encode) {
+        if (encode === void 0) { encode = true; }
+        return new PDFObjectStream(context, objects, encode);
+    };
+    return PDFObjectStream;
+}(PDFFlateStream));
+
+export { PDFObjectStream as default };