art-bd-ui 1.0.21 → 1.0.23

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

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

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

@@ -0,0 +1,98 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+var tslib_es6 = require('../../../../tslib/tslib.es6.js');
+var PDFDict = require('../objects/PDFDict.js');
+var PDFName = require('../objects/PDFName.js');
+require('../acroform/PDFAcroButton.js');
+require('../acroform/PDFAcroCheckBox.js');
+require('../acroform/PDFAcroChoice.js');
+require('../acroform/PDFAcroComboBox.js');
+require('../acroform/PDFAcroField.js');
+var PDFAcroForm = require('../acroform/PDFAcroForm.js');
+require('../acroform/PDFAcroListBox.js');
+require('../acroform/PDFAcroNonTerminal.js');
+require('../acroform/PDFAcroPushButton.js');
+require('../acroform/PDFAcroRadioButton.js');
+require('../acroform/PDFAcroSignature.js');
+require('../acroform/PDFAcroTerminal.js');
+require('../acroform/PDFAcroText.js');
+require('../acroform/flags.js');
+require('../objects/PDFNumber.js');
+require('../objects/PDFArray.js');
+require('../objects/PDFRef.js');
+var ViewerPreferences = require('../interactive/ViewerPreferences.js');
+
+var PDFCatalog = /** @class */ (function (_super) {
+    tslib_es6.__extends(PDFCatalog, _super);
+    function PDFCatalog() {
+        return _super !== null && _super.apply(this, arguments) || this;
+    }
+    PDFCatalog.prototype.Pages = function () {
+        return this.lookup(PDFName.default.of('Pages'), PDFDict.default);
+    };
+    PDFCatalog.prototype.AcroForm = function () {
+        return this.lookupMaybe(PDFName.default.of('AcroForm'), PDFDict.default);
+    };
+    PDFCatalog.prototype.getAcroForm = function () {
+        var dict = this.AcroForm();
+        if (!dict)
+            return undefined;
+        return PDFAcroForm.default.fromDict(dict);
+    };
+    PDFCatalog.prototype.getOrCreateAcroForm = function () {
+        var acroForm = this.getAcroForm();
+        if (!acroForm) {
+            acroForm = PDFAcroForm.default.create(this.context);
+            var acroFormRef = this.context.register(acroForm.dict);
+            this.set(PDFName.default.of('AcroForm'), acroFormRef);
+        }
+        return acroForm;
+    };
+    PDFCatalog.prototype.ViewerPreferences = function () {
+        return this.lookupMaybe(PDFName.default.of('ViewerPreferences'), PDFDict.default);
+    };
+    PDFCatalog.prototype.getViewerPreferences = function () {
+        var dict = this.ViewerPreferences();
+        if (!dict)
+            return undefined;
+        return ViewerPreferences.default.fromDict(dict);
+    };
+    PDFCatalog.prototype.getOrCreateViewerPreferences = function () {
+        var viewerPrefs = this.getViewerPreferences();
+        if (!viewerPrefs) {
+            viewerPrefs = ViewerPreferences.default.create(this.context);
+            var viewerPrefsRef = this.context.register(viewerPrefs.dict);
+            this.set(PDFName.default.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.default.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.default.of('Type'), PDFName.default.of('Catalog'));
+        dict.set(PDFName.default.of('Pages'), pages);
+        return new PDFCatalog(dict, context);
+    };
+    PDFCatalog.fromMapWithContext = function (map, context) {
+        return new PDFCatalog(map, context);
+    };
+    return PDFCatalog;
+}(PDFDict.default));
+
+exports.default = PDFCatalog;

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

@@ -0,0 +1,63 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+var tslib_es6 = require('../../../../tslib/tslib.es6.js');
+var PDFFlateStream = require('./PDFFlateStream.js');
+var CharCodes = require('../syntax/CharCodes.js');
+
+var PDFContentStream = /** @class */ (function (_super) {
+    tslib_es6.__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.default.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.default));
+
+exports.default = PDFContentStream;

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

@@ -0,0 +1,195 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+var tslib_es6 = require('../../../../tslib/tslib.es6.js');
+var PDFName = require('../objects/PDFName.js');
+var PDFRef = require('../objects/PDFRef.js');
+var PDFFlateStream = require('./PDFFlateStream.js');
+var arrays = require('../../utils/arrays.js');
+require('../../utils/unicode.js');
+var numbers = require('../../utils/numbers.js');
+require('../../utils/base64.js');
+require('../../utils/objects.js');
+require('../../utils/pdfDocEncoding.js');
+var Cache = require('../../utils/Cache.js');
+
+exports.EntryType = void 0;
+(function (EntryType) {
+    EntryType[EntryType["Deleted"] = 0] = "Deleted";
+    EntryType[EntryType["Uncompressed"] = 1] = "Uncompressed";
+    EntryType[EntryType["Compressed"] = 2] = "Compressed";
+})(exports.EntryType || (exports.EntryType = {}));
+/**
+ * Entries should be added using the [[addDeletedEntry]],
+ * [[addUncompressedEntry]], and [[addCompressedEntry]] methods
+ * **in order of ascending object number**.
+ */
+var PDFCrossRefStream = /** @class */ (function (_super) {
+    tslib_es6.__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 === exports.EntryType.Deleted) {
+                    var type = entry.type, nextFreeObjectNumber = entry.nextFreeObjectNumber, ref = entry.ref;
+                    entryTuples[idx] = [type, nextFreeObjectNumber, ref.generationNumber];
+                }
+                if (entry.type === exports.EntryType.Uncompressed) {
+                    var type = entry.type, offset = entry.offset, ref = entry.ref;
+                    entryTuples[idx] = [type, offset, ref.generationNumber];
+                }
+                if (entry.type === exports.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 = numbers.sizeInBytes(first);
+                var secondSize = numbers.sizeInBytes(second);
+                var thirdSize = numbers.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.default.populatedBy(_this.computeEntryTuples);
+        _this.maxByteWidthsCache = Cache.default.populatedBy(_this.computeMaxEntryByteWidths);
+        _this.indexCache = Cache.default.populatedBy(_this.computeIndex);
+        dict.set(PDFName.default.of('Type'), PDFName.default.of('XRef'));
+        return _this;
+    }
+    PDFCrossRefStream.prototype.addDeletedEntry = function (ref, nextFreeObjectNumber) {
+        var type = exports.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 = exports.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 = exports.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 = arrays.reverseArray(numbers.bytesFor(first));
+            var secondBytes = arrays.reverseArray(numbers.bytesFor(second));
+            var thirdBytes = arrays.reverseArray(numbers.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 = arrays.reverseArray(numbers.bytesFor(first));
+            var secondBytes = arrays.reverseArray(numbers.bytesFor(second));
+            var thirdBytes = arrays.reverseArray(numbers.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 = arrays.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.default.of('W'), context.obj(byteWidths));
+        this.dict.set(PDFName.default.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.default.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.default));
+
+exports.default = PDFCrossRefStream;

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

@@ -0,0 +1,42 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+var tslib_es6 = require('../../../../tslib/tslib.es6.js');
+var index = require('../../../../../_virtual/index8.js');
+var errors = require('../errors.js');
+var PDFName = require('../objects/PDFName.js');
+var PDFStream = require('../objects/PDFStream.js');
+require('../../utils/base64.js');
+require('../../utils/unicode.js');
+require('../../utils/objects.js');
+require('../../utils/pdfDocEncoding.js');
+var Cache = require('../../utils/Cache.js');
+
+var PDFFlateStream = /** @class */ (function (_super) {
+    tslib_es6.__extends(PDFFlateStream, _super);
+    function PDFFlateStream(dict, encode) {
+        var _this = _super.call(this, dict) || this;
+        _this.computeContents = function () {
+            var unencodedContents = _this.getUnencodedContents();
+            return _this.encode ? index.default.deflate(unencodedContents) : unencodedContents;
+        };
+        _this.encode = encode;
+        if (encode)
+            dict.set(PDFName.default.of('Filter'), PDFName.default.of('FlateDecode'));
+        _this.contentsCache = Cache.default.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 errors.MethodNotImplementedError(this.constructor.name, 'getUnencodedContents');
+    };
+    return PDFFlateStream;
+}(PDFStream.default));
+
+exports.default = PDFFlateStream;

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

@@ -0,0 +1,86 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+var tslib_es6 = require('../../../../tslib/tslib.es6.js');
+var PDFName = require('../objects/PDFName.js');
+var PDFNumber = require('../objects/PDFNumber.js');
+var PDFFlateStream = require('./PDFFlateStream.js');
+var CharCodes = require('../syntax/CharCodes.js');
+var arrays = require('../../utils/arrays.js');
+var strings = require('../../utils/strings.js');
+require('../../utils/unicode.js');
+require('../../utils/base64.js');
+require('../../utils/objects.js');
+require('../../utils/pdfDocEncoding.js');
+require('../../utils/Cache.js');
+
+var PDFObjectStream = /** @class */ (function (_super) {
+    tslib_es6.__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.default.of('Type'), PDFName.default.of('ObjStm'));
+        _this.dict.set(PDFName.default.of('N'), PDFNumber.default.of(_this.objects.length));
+        _this.dict.set(PDFName.default.of('First'), PDFNumber.default.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 = strings.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.default.Newline;
+        }
+        return buffer;
+    };
+    PDFObjectStream.prototype.getUnencodedContentsSize = function () {
+        return (this.offsetsString.length +
+            arrays.last(this.offsets)[1] +
+            arrays.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.default));
+
+exports.default = PDFObjectStream;