art-bd-ui 1.0.21 → 1.0.23

package/dist/esm/node_modules/pdf-lib/es/core/writers/PDFStreamWriter.js

@@ -0,0 +1,118 @@
+import { __extends, __awaiter, __generator } from '../../../../tslib/tslib.es6.js';
+import PDFHeader from '../document/PDFHeader.js';
+import PDFTrailer from '../document/PDFTrailer.js';
+import PDFInvalidObject from '../objects/PDFInvalidObject.js';
+import PDFName from '../objects/PDFName.js';
+import PDFNumber from '../objects/PDFNumber.js';
+import PDFRef from '../objects/PDFRef.js';
+import PDFStream from '../objects/PDFStream.js';
+import PDFCrossRefStream from '../structures/PDFCrossRefStream.js';
+import PDFObjectStream from '../structures/PDFObjectStream.js';
+import PDFWriter from './PDFWriter.js';
+import { last } from '../../utils/arrays.js';
+import { waitForTick } from '../../utils/async.js';
+import '../../utils/unicode.js';
+import '../../utils/base64.js';
+import '../../utils/objects.js';
+import '../../utils/pdfDocEncoding.js';
+import '../../utils/Cache.js';
+
+var PDFStreamWriter = /** @class */ (function (_super) {
+    __extends(PDFStreamWriter, _super);
+    function PDFStreamWriter(context, objectsPerTick, encodeStreams, objectsPerStream) {
+        var _this = _super.call(this, context, objectsPerTick) || this;
+        _this.encodeStreams = encodeStreams;
+        _this.objectsPerStream = objectsPerStream;
+        return _this;
+    }
+    PDFStreamWriter.prototype.computeBufferSize = function () {
+        return __awaiter(this, void 0, void 0, function () {
+            var objectNumber, header, size, xrefStream, uncompressedObjects, compressedObjects, objectStreamRefs, indirectObjects, idx, len, indirectObject, ref, object, shouldNotCompress, chunk, objectStreamRef, idx, len, chunk, ref, objectStream, xrefStreamRef, xrefOffset, trailer;
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0:
+                        objectNumber = this.context.largestObjectNumber + 1;
+                        header = PDFHeader.forVersion(1, 7);
+                        size = header.sizeInBytes() + 2;
+                        xrefStream = PDFCrossRefStream.create(this.createTrailerDict(), this.encodeStreams);
+                        uncompressedObjects = [];
+                        compressedObjects = [];
+                        objectStreamRefs = [];
+                        indirectObjects = this.context.enumerateIndirectObjects();
+                        idx = 0, len = indirectObjects.length;
+                        _a.label = 1;
+                    case 1:
+                        if (!(idx < len)) return [3 /*break*/, 6];
+                        indirectObject = indirectObjects[idx];
+                        ref = indirectObject[0], object = indirectObject[1];
+                        shouldNotCompress = ref === this.context.trailerInfo.Encrypt ||
+                            object instanceof PDFStream ||
+                            object instanceof PDFInvalidObject ||
+                            ref.generationNumber !== 0;
+                        if (!shouldNotCompress) return [3 /*break*/, 4];
+                        uncompressedObjects.push(indirectObject);
+                        xrefStream.addUncompressedEntry(ref, size);
+                        size += this.computeIndirectObjectSize(indirectObject);
+                        if (!this.shouldWaitForTick(1)) return [3 /*break*/, 3];
+                        return [4 /*yield*/, waitForTick()];
+                    case 2:
+                        _a.sent();
+                        _a.label = 3;
+                    case 3: return [3 /*break*/, 5];
+                    case 4:
+                        chunk = last(compressedObjects);
+                        objectStreamRef = last(objectStreamRefs);
+                        if (!chunk || chunk.length % this.objectsPerStream === 0) {
+                            chunk = [];
+                            compressedObjects.push(chunk);
+                            objectStreamRef = PDFRef.of(objectNumber++);
+                            objectStreamRefs.push(objectStreamRef);
+                        }
+                        xrefStream.addCompressedEntry(ref, objectStreamRef, chunk.length);
+                        chunk.push(indirectObject);
+                        _a.label = 5;
+                    case 5:
+                        idx++;
+                        return [3 /*break*/, 1];
+                    case 6:
+                        idx = 0, len = compressedObjects.length;
+                        _a.label = 7;
+                    case 7:
+                        if (!(idx < len)) return [3 /*break*/, 10];
+                        chunk = compressedObjects[idx];
+                        ref = objectStreamRefs[idx];
+                        objectStream = PDFObjectStream.withContextAndObjects(this.context, chunk, this.encodeStreams);
+                        xrefStream.addUncompressedEntry(ref, size);
+                        size += this.computeIndirectObjectSize([ref, objectStream]);
+                        uncompressedObjects.push([ref, objectStream]);
+                        if (!this.shouldWaitForTick(chunk.length)) return [3 /*break*/, 9];
+                        return [4 /*yield*/, waitForTick()];
+                    case 8:
+                        _a.sent();
+                        _a.label = 9;
+                    case 9:
+                        idx++;
+                        return [3 /*break*/, 7];
+                    case 10:
+                        xrefStreamRef = PDFRef.of(objectNumber++);
+                        xrefStream.dict.set(PDFName.of('Size'), PDFNumber.of(objectNumber));
+                        xrefStream.addUncompressedEntry(xrefStreamRef, size);
+                        xrefOffset = size;
+                        size += this.computeIndirectObjectSize([xrefStreamRef, xrefStream]);
+                        uncompressedObjects.push([xrefStreamRef, xrefStream]);
+                        trailer = PDFTrailer.forLastCrossRefSectionOffset(xrefOffset);
+                        size += trailer.sizeInBytes();
+                        return [2 /*return*/, { size: size, header: header, indirectObjects: uncompressedObjects, trailer: trailer }];
+                }
+            });
+        });
+    };
+    PDFStreamWriter.forContext = function (context, objectsPerTick, encodeStreams, objectsPerStream) {
+        if (encodeStreams === void 0) { encodeStreams = true; }
+        if (objectsPerStream === void 0) { objectsPerStream = 50; }
+        return new PDFStreamWriter(context, objectsPerTick, encodeStreams, objectsPerStream);
+    };
+    return PDFStreamWriter;
+}(PDFWriter));
+
+export { PDFStreamWriter as default };

package/dist/esm/node_modules/pdf-lib/es/core/writers/PDFWriter.js

@@ -0,0 +1,149 @@
+import { __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 PDFTrailerDict from '../document/PDFTrailerDict.js';
+import PDFObjectStream from '../structures/PDFObjectStream.js';
+import CharCodes from '../syntax/CharCodes.js';
+import '../../utils/base64.js';
+import { copyStringIntoBuffer } from '../../utils/strings.js';
+import { waitForTick } from '../../utils/async.js';
+import '../../utils/unicode.js';
+import '../../utils/objects.js';
+import '../../utils/pdfDocEncoding.js';
+import '../../utils/Cache.js';
+
+var PDFWriter = /** @class */ (function () {
+    function PDFWriter(context, objectsPerTick) {
+        var _this = this;
+        this.parsedObjects = 0;
+        this.shouldWaitForTick = function (n) {
+            _this.parsedObjects += n;
+            return _this.parsedObjects % _this.objectsPerTick === 0;
+        };
+        this.context = context;
+        this.objectsPerTick = objectsPerTick;
+    }
+    PDFWriter.prototype.serializeToBuffer = function () {
+        return __awaiter(this, void 0, void 0, function () {
+            var _a, size, header, indirectObjects, xref, trailerDict, trailer, offset, buffer, idx, len, _b, ref, object, objectNumber, generationNumber, n;
+            return __generator(this, function (_c) {
+                switch (_c.label) {
+                    case 0: return [4 /*yield*/, this.computeBufferSize()];
+                    case 1:
+                        _a = _c.sent(), size = _a.size, header = _a.header, indirectObjects = _a.indirectObjects, xref = _a.xref, trailerDict = _a.trailerDict, trailer = _a.trailer;
+                        offset = 0;
+                        buffer = new Uint8Array(size);
+                        offset += header.copyBytesInto(buffer, offset);
+                        buffer[offset++] = CharCodes.Newline;
+                        buffer[offset++] = CharCodes.Newline;
+                        idx = 0, len = indirectObjects.length;
+                        _c.label = 2;
+                    case 2:
+                        if (!(idx < len)) return [3 /*break*/, 5];
+                        _b = indirectObjects[idx], ref = _b[0], object = _b[1];
+                        objectNumber = String(ref.objectNumber);
+                        offset += copyStringIntoBuffer(objectNumber, buffer, offset);
+                        buffer[offset++] = CharCodes.Space;
+                        generationNumber = String(ref.generationNumber);
+                        offset += copyStringIntoBuffer(generationNumber, buffer, offset);
+                        buffer[offset++] = CharCodes.Space;
+                        buffer[offset++] = CharCodes.o;
+                        buffer[offset++] = CharCodes.b;
+                        buffer[offset++] = CharCodes.j;
+                        buffer[offset++] = CharCodes.Newline;
+                        offset += object.copyBytesInto(buffer, offset);
+                        buffer[offset++] = CharCodes.Newline;
+                        buffer[offset++] = CharCodes.e;
+                        buffer[offset++] = CharCodes.n;
+                        buffer[offset++] = CharCodes.d;
+                        buffer[offset++] = CharCodes.o;
+                        buffer[offset++] = CharCodes.b;
+                        buffer[offset++] = CharCodes.j;
+                        buffer[offset++] = CharCodes.Newline;
+                        buffer[offset++] = CharCodes.Newline;
+                        n = object instanceof PDFObjectStream ? object.getObjectsCount() : 1;
+                        if (!this.shouldWaitForTick(n)) return [3 /*break*/, 4];
+                        return [4 /*yield*/, waitForTick()];
+                    case 3:
+                        _c.sent();
+                        _c.label = 4;
+                    case 4:
+                        idx++;
+                        return [3 /*break*/, 2];
+                    case 5:
+                        if (xref) {
+                            offset += xref.copyBytesInto(buffer, offset);
+                            buffer[offset++] = CharCodes.Newline;
+                        }
+                        if (trailerDict) {
+                            offset += trailerDict.copyBytesInto(buffer, offset);
+                            buffer[offset++] = CharCodes.Newline;
+                            buffer[offset++] = CharCodes.Newline;
+                        }
+                        offset += trailer.copyBytesInto(buffer, offset);
+                        return [2 /*return*/, buffer];
+                }
+            });
+        });
+    };
+    PDFWriter.prototype.computeIndirectObjectSize = function (_a) {
+        var ref = _a[0], object = _a[1];
+        var refSize = ref.sizeInBytes() + 3; // 'R' -> 'obj\n'
+        var objectSize = object.sizeInBytes() + 9; // '\nendobj\n\n'
+        return refSize + objectSize;
+    };
+    PDFWriter.prototype.createTrailerDict = function () {
+        return this.context.obj({
+            Size: this.context.largestObjectNumber + 1,
+            Root: this.context.trailerInfo.Root,
+            Encrypt: this.context.trailerInfo.Encrypt,
+            Info: this.context.trailerInfo.Info,
+            ID: this.context.trailerInfo.ID,
+        });
+    };
+    PDFWriter.prototype.computeBufferSize = function () {
+        return __awaiter(this, void 0, void 0, function () {
+            var header, size, xref, indirectObjects, idx, len, indirectObject, ref, xrefOffset, trailerDict, trailer;
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0:
+                        header = PDFHeader.forVersion(1, 7);
+                        size = header.sizeInBytes() + 2;
+                        xref = PDFCrossRefSection.create();
+                        indirectObjects = this.context.enumerateIndirectObjects();
+                        idx = 0, len = indirectObjects.length;
+                        _a.label = 1;
+                    case 1:
+                        if (!(idx < len)) return [3 /*break*/, 4];
+                        indirectObject = indirectObjects[idx];
+                        ref = indirectObject[0];
+                        xref.addEntry(ref, size);
+                        size += this.computeIndirectObjectSize(indirectObject);
+                        if (!this.shouldWaitForTick(1)) return [3 /*break*/, 3];
+                        return [4 /*yield*/, waitForTick()];
+                    case 2:
+                        _a.sent();
+                        _a.label = 3;
+                    case 3:
+                        idx++;
+                        return [3 /*break*/, 1];
+                    case 4:
+                        xrefOffset = size;
+                        size += xref.sizeInBytes() + 1; // '\n'
+                        trailerDict = PDFTrailerDict.of(this.createTrailerDict());
+                        size += trailerDict.sizeInBytes() + 2; // '\n\n'
+                        trailer = PDFTrailer.forLastCrossRefSectionOffset(xrefOffset);
+                        size += trailer.sizeInBytes();
+                        return [2 /*return*/, { size: size, header: header, indirectObjects: indirectObjects, xref: xref, trailerDict: trailerDict, trailer: trailer }];
+                }
+            });
+        });
+    };
+    PDFWriter.forContext = function (context, objectsPerTick) {
+        return new PDFWriter(context, objectsPerTick);
+    };
+    return PDFWriter;
+}());
+
+export { PDFWriter as default };

package/dist/esm/node_modules/pdf-lib/es/utils/Cache.js

@@ -0,0 +1,21 @@
+var Cache = /** @class */ (function () {
+    function Cache(populate) {
+        this.populate = populate;
+        this.value = undefined;
+    }
+    Cache.prototype.getValue = function () {
+        return this.value;
+    };
+    Cache.prototype.access = function () {
+        if (!this.value)
+            this.value = this.populate();
+        return this.value;
+    };
+    Cache.prototype.invalidate = function () {
+        this.value = undefined;
+    };
+    Cache.populatedBy = function (populate) { return new Cache(populate); };
+    return Cache;
+}());
+
+export { Cache as default };

package/dist/esm/node_modules/pdf-lib/es/utils/arrays.js

@@ -0,0 +1,131 @@
+import { decodeFromBase64DataUri } from './base64.js';
+import { charFromCode } from './strings.js';
+
+var last = function (array) { return array[array.length - 1]; };
+// export const dropLast = <T>(array: T[]): T[] =>
+// array.slice(0, array.length - 1);
+var typedArrayFor = function (value) {
+    if (value instanceof Uint8Array)
+        return value;
+    var length = value.length;
+    var typedArray = new Uint8Array(length);
+    for (var idx = 0; idx < length; idx++) {
+        typedArray[idx] = value.charCodeAt(idx);
+    }
+    return typedArray;
+};
+var mergeIntoTypedArray = function () {
+    var arrays = [];
+    for (var _i = 0; _i < arguments.length; _i++) {
+        arrays[_i] = arguments[_i];
+    }
+    var arrayCount = arrays.length;
+    var typedArrays = [];
+    for (var idx = 0; idx < arrayCount; idx++) {
+        var element = arrays[idx];
+        typedArrays[idx] =
+            element instanceof Uint8Array ? element : typedArrayFor(element);
+    }
+    var totalSize = 0;
+    for (var idx = 0; idx < arrayCount; idx++) {
+        totalSize += arrays[idx].length;
+    }
+    var merged = new Uint8Array(totalSize);
+    var offset = 0;
+    for (var arrIdx = 0; arrIdx < arrayCount; arrIdx++) {
+        var arr = typedArrays[arrIdx];
+        for (var byteIdx = 0, arrLen = arr.length; byteIdx < arrLen; byteIdx++) {
+            merged[offset++] = arr[byteIdx];
+        }
+    }
+    return merged;
+};
+var mergeUint8Arrays = function (arrays) {
+    var totalSize = 0;
+    for (var idx = 0, len = arrays.length; idx < len; idx++) {
+        totalSize += arrays[idx].length;
+    }
+    var mergedBuffer = new Uint8Array(totalSize);
+    var offset = 0;
+    for (var idx = 0, len = arrays.length; idx < len; idx++) {
+        var array = arrays[idx];
+        mergedBuffer.set(array, offset);
+        offset += array.length;
+    }
+    return mergedBuffer;
+};
+var arrayAsString = function (array) {
+    var str = '';
+    for (var idx = 0, len = array.length; idx < len; idx++) {
+        str += charFromCode(array[idx]);
+    }
+    return str;
+};
+var byAscendingId = function (a, b) { return a.id - b.id; };
+var sortedUniq = function (array, indexer) {
+    var uniq = [];
+    for (var idx = 0, len = array.length; idx < len; idx++) {
+        var curr = array[idx];
+        var prev = array[idx - 1];
+        if (idx === 0 || indexer(curr) !== indexer(prev)) {
+            uniq.push(curr);
+        }
+    }
+    return uniq;
+};
+// Arrays and TypedArrays in JS both have .reverse() methods, which would seem
+// to negate the need for this function. However, not all runtimes support this
+// method (e.g. React Native). This function compensates for that fact.
+var reverseArray = function (array) {
+    var arrayLen = array.length;
+    for (var idx = 0, len = Math.floor(arrayLen / 2); idx < len; idx++) {
+        var leftIdx = idx;
+        var rightIdx = arrayLen - idx - 1;
+        var temp = array[idx];
+        array[leftIdx] = array[rightIdx];
+        array[rightIdx] = temp;
+    }
+    return array;
+};
+var sum = function (array) {
+    var total = 0;
+    for (var idx = 0, len = array.length; idx < len; idx++) {
+        total += array[idx];
+    }
+    return total;
+};
+var range = function (start, end) {
+    var arr = new Array(end - start);
+    for (var idx = 0, len = arr.length; idx < len; idx++) {
+        arr[idx] = start + idx;
+    }
+    return arr;
+};
+var pluckIndices = function (arr, indices) {
+    var plucked = new Array(indices.length);
+    for (var idx = 0, len = indices.length; idx < len; idx++) {
+        plucked[idx] = arr[indices[idx]];
+    }
+    return plucked;
+};
+var canBeConvertedToUint8Array = function (input) {
+    return input instanceof Uint8Array ||
+        input instanceof ArrayBuffer ||
+        typeof input === 'string';
+};
+var toUint8Array = function (input) {
+    if (typeof input === 'string') {
+        return decodeFromBase64DataUri(input);
+    }
+    else if (input instanceof ArrayBuffer) {
+        return new Uint8Array(input);
+    }
+    else if (input instanceof Uint8Array) {
+        return input;
+    }
+    else {
+        throw new TypeError('`input` must be one of `string | ArrayBuffer | Uint8Array`');
+    }
+};
+
+export { arrayAsString, byAscendingId, canBeConvertedToUint8Array, last, mergeIntoTypedArray, mergeUint8Arrays, pluckIndices, range, reverseArray, sortedUniq, sum, toUint8Array, typedArrayFor };

package/dist/esm/node_modules/pdf-lib/es/utils/async.js

@@ -0,0 +1,11 @@
+/**
+ * Returns a Promise that resolves after at least one tick of the
+ * Macro Task Queue occurs.
+ */
+var waitForTick = function () {
+    return new Promise(function (resolve) {
+        setTimeout(function () { return resolve(); }, 0);
+    });
+};
+
+export { waitForTick };

package/dist/esm/node_modules/pdf-lib/es/utils/base64.js

@@ -0,0 +1,85 @@
+/*
+ * The `chars`, `lookup`, `encode`, and `decode` members of this file are
+ * licensed under the following:
+ *
+ *     base64-arraybuffer
+ *     https://github.com/niklasvh/base64-arraybuffer
+ *
+ *     Copyright (c) 2012 Niklas von Hertzen
+ *     Licensed under the MIT license.
+ *
+ */
+var chars = 'ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/';
+// Use a lookup table to find the index.
+var lookup = new Uint8Array(256);
+for (var i = 0; i < chars.length; i++) {
+    lookup[chars.charCodeAt(i)] = i;
+}
+var encodeToBase64 = function (bytes) {
+    var base64 = '';
+    var len = bytes.length;
+    for (var i = 0; i < len; i += 3) {
+        base64 += chars[bytes[i] >> 2];
+        base64 += chars[((bytes[i] & 3) << 4) | (bytes[i + 1] >> 4)];
+        base64 += chars[((bytes[i + 1] & 15) << 2) | (bytes[i + 2] >> 6)];
+        base64 += chars[bytes[i + 2] & 63];
+    }
+    if (len % 3 === 2) {
+        base64 = base64.substring(0, base64.length - 1) + '=';
+    }
+    else if (len % 3 === 1) {
+        base64 = base64.substring(0, base64.length - 2) + '==';
+    }
+    return base64;
+};
+var decodeFromBase64 = function (base64) {
+    var bufferLength = base64.length * 0.75;
+    var len = base64.length;
+    var i;
+    var p = 0;
+    var encoded1;
+    var encoded2;
+    var encoded3;
+    var encoded4;
+    if (base64[base64.length - 1] === '=') {
+        bufferLength--;
+        if (base64[base64.length - 2] === '=') {
+            bufferLength--;
+        }
+    }
+    var bytes = new Uint8Array(bufferLength);
+    for (i = 0; i < len; i += 4) {
+        encoded1 = lookup[base64.charCodeAt(i)];
+        encoded2 = lookup[base64.charCodeAt(i + 1)];
+        encoded3 = lookup[base64.charCodeAt(i + 2)];
+        encoded4 = lookup[base64.charCodeAt(i + 3)];
+        bytes[p++] = (encoded1 << 2) | (encoded2 >> 4);
+        bytes[p++] = ((encoded2 & 15) << 4) | (encoded3 >> 2);
+        bytes[p++] = ((encoded3 & 3) << 6) | (encoded4 & 63);
+    }
+    return bytes;
+};
+// This regex is designed to be as flexible as possible. It will parse certain
+// invalid data URIs.
+var DATA_URI_PREFIX_REGEX = /^(data)?:?([\w\/\+]+)?;?(charset=[\w-]+|base64)?.*,/i;
+/**
+ * If the `dataUri` input is a data URI, then the data URI prefix must not be
+ * longer than 100 characters, or this function will fail to decode it.
+ *
+ * @param dataUri a base64 data URI or plain base64 string
+ * @returns a Uint8Array containing the decoded input
+ */
+var decodeFromBase64DataUri = function (dataUri) {
+    var trimmedUri = dataUri.trim();
+    var prefix = trimmedUri.substring(0, 100);
+    var res = prefix.match(DATA_URI_PREFIX_REGEX);
+    // Assume it's not a data URI - just a plain base64 string
+    if (!res)
+        return decodeFromBase64(trimmedUri);
+    // Remove the data URI prefix and parse the remainder as a base64 string
+    var fullMatch = res[0];
+    var data = trimmedUri.substring(fullMatch.length);
+    return decodeFromBase64(data);
+};
+
+export { decodeFromBase64, decodeFromBase64DataUri, encodeToBase64 };

package/dist/esm/node_modules/pdf-lib/es/utils/errors.js

@@ -0,0 +1,5 @@
+var error = function (msg) {
+    throw new Error(msg);
+};
+
+export { error };

package/dist/esm/node_modules/pdf-lib/es/utils/numbers.js

@@ -0,0 +1,55 @@
+// tslint:disable radix
+/**
+ * Converts a number to its string representation in decimal. This function
+ * differs from simply converting a number to a string with `.toString()`
+ * because this function's output string will **not** contain exponential
+ * notation.
+ *
+ * Credit: https://stackoverflow.com/a/46545519
+ */
+var numberToString = function (num) {
+    var numStr = String(num);
+    if (Math.abs(num) < 1.0) {
+        var e = parseInt(num.toString().split('e-')[1]);
+        if (e) {
+            var negative = num < 0;
+            if (negative)
+                num *= -1;
+            num *= Math.pow(10, e - 1);
+            numStr = '0.' + new Array(e).join('0') + num.toString().substring(2);
+            if (negative)
+                numStr = '-' + numStr;
+        }
+    }
+    else {
+        var e = parseInt(num.toString().split('+')[1]);
+        if (e > 20) {
+            e -= 20;
+            num /= Math.pow(10, e);
+            numStr = num.toString() + new Array(e + 1).join('0');
+        }
+    }
+    return numStr;
+};
+var sizeInBytes = function (n) { return Math.ceil(n.toString(2).length / 8); };
+/**
+ * Converts a number into its constituent bytes and returns them as
+ * a number[].
+ *
+ * Returns most significant byte as first element in array. It may be necessary
+ * to call .reverse() to get the bits in the desired order.
+ *
+ * Example:
+ *   bytesFor(0x02A41E) => [ 0b10, 0b10100100, 0b11110 ]
+ *
+ * Credit for algorithm: https://stackoverflow.com/a/1936865
+ */
+var bytesFor = function (n) {
+    var bytes = new Uint8Array(sizeInBytes(n));
+    for (var i = 1; i <= bytes.length; i++) {
+        bytes[i - 1] = n >> ((bytes.length - i) * 8);
+    }
+    return bytes;
+};
+
+export { bytesFor, numberToString, sizeInBytes };

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

@@ -0,0 +1,11 @@
+import { FontNames } from '../../../@pdf-lib/standard-fonts/es/Font.js';
+import '../../../@pdf-lib/standard-fonts/es/Encoding.js';
+
+var values = function (obj) { return Object.keys(obj).map(function (k) { return obj[k]; }); };
+var StandardFontValues = values(FontNames);
+var isStandardFont = function (input) {
+    return StandardFontValues.includes(input);
+};
+var rectanglesAreEqual = function (a, b) { return a.x === b.x && a.y === b.y && a.width === b.width && a.height === b.height; };
+
+export { StandardFontValues, isStandardFont, rectanglesAreEqual, values };

package/dist/esm/node_modules/pdf-lib/es/utils/pdfDocEncoding.js

@@ -0,0 +1,68 @@
+import { toCharCode } from './strings.js';
+
+// Mapping from PDFDocEncoding to Unicode code point
+var pdfDocEncodingToUnicode = new Uint16Array(256);
+// Initialize the code points which are the same
+for (var idx = 0; idx < 256; idx++) {
+    pdfDocEncodingToUnicode[idx] = idx;
+}
+// Set differences (see "Table D.2 – PDFDocEncoding Character Set" of the PDF spec)
+pdfDocEncodingToUnicode[0x16] = toCharCode('\u0017'); // SYNCRONOUS IDLE
+pdfDocEncodingToUnicode[0x18] = toCharCode('\u02D8'); // BREVE
+pdfDocEncodingToUnicode[0x19] = toCharCode('\u02C7'); // CARON
+pdfDocEncodingToUnicode[0x1a] = toCharCode('\u02C6'); // MODIFIER LETTER CIRCUMFLEX ACCENT
+pdfDocEncodingToUnicode[0x1b] = toCharCode('\u02D9'); // DOT ABOVE
+pdfDocEncodingToUnicode[0x1c] = toCharCode('\u02DD'); // DOUBLE ACUTE ACCENT
+pdfDocEncodingToUnicode[0x1d] = toCharCode('\u02DB'); // OGONEK
+pdfDocEncodingToUnicode[0x1e] = toCharCode('\u02DA'); // RING ABOVE
+pdfDocEncodingToUnicode[0x1f] = toCharCode('\u02DC'); // SMALL TILDE
+pdfDocEncodingToUnicode[0x7f] = toCharCode('\uFFFD'); // REPLACEMENT CHARACTER (box with questionmark)
+pdfDocEncodingToUnicode[0x80] = toCharCode('\u2022'); // BULLET
+pdfDocEncodingToUnicode[0x81] = toCharCode('\u2020'); // DAGGER
+pdfDocEncodingToUnicode[0x82] = toCharCode('\u2021'); // DOUBLE DAGGER
+pdfDocEncodingToUnicode[0x83] = toCharCode('\u2026'); // HORIZONTAL ELLIPSIS
+pdfDocEncodingToUnicode[0x84] = toCharCode('\u2014'); // EM DASH
+pdfDocEncodingToUnicode[0x85] = toCharCode('\u2013'); // EN DASH
+pdfDocEncodingToUnicode[0x86] = toCharCode('\u0192'); // LATIN SMALL LETTER SCRIPT F
+pdfDocEncodingToUnicode[0x87] = toCharCode('\u2044'); // FRACTION SLASH (solidus)
+pdfDocEncodingToUnicode[0x88] = toCharCode('\u2039'); // SINGLE LEFT-POINTING ANGLE QUOTATION MARK
+pdfDocEncodingToUnicode[0x89] = toCharCode('\u203A'); // SINGLE RIGHT-POINTING ANGLE QUOTATION MARK
+pdfDocEncodingToUnicode[0x8a] = toCharCode('\u2212'); // MINUS SIGN
+pdfDocEncodingToUnicode[0x8b] = toCharCode('\u2030'); // PER MILLE SIGN
+pdfDocEncodingToUnicode[0x8c] = toCharCode('\u201E'); // DOUBLE LOW-9 QUOTATION MARK (quotedblbase)
+pdfDocEncodingToUnicode[0x8d] = toCharCode('\u201C'); // LEFT DOUBLE QUOTATION MARK (quotedblleft)
+pdfDocEncodingToUnicode[0x8e] = toCharCode('\u201D'); // RIGHT DOUBLE QUOTATION MARK (quotedblright)
+pdfDocEncodingToUnicode[0x8f] = toCharCode('\u2018'); // LEFT SINGLE QUOTATION MARK (quoteleft)
+pdfDocEncodingToUnicode[0x90] = toCharCode('\u2019'); // RIGHT SINGLE QUOTATION MARK (quoteright)
+pdfDocEncodingToUnicode[0x91] = toCharCode('\u201A'); // SINGLE LOW-9 QUOTATION MARK (quotesinglbase)
+pdfDocEncodingToUnicode[0x92] = toCharCode('\u2122'); // TRADE MARK SIGN
+pdfDocEncodingToUnicode[0x93] = toCharCode('\uFB01'); // LATIN SMALL LIGATURE FI
+pdfDocEncodingToUnicode[0x94] = toCharCode('\uFB02'); // LATIN SMALL LIGATURE FL
+pdfDocEncodingToUnicode[0x95] = toCharCode('\u0141'); // LATIN CAPITAL LETTER L WITH STROKE
+pdfDocEncodingToUnicode[0x96] = toCharCode('\u0152'); // LATIN CAPITAL LIGATURE OE
+pdfDocEncodingToUnicode[0x97] = toCharCode('\u0160'); // LATIN CAPITAL LETTER S WITH CARON
+pdfDocEncodingToUnicode[0x98] = toCharCode('\u0178'); // LATIN CAPITAL LETTER Y WITH DIAERESIS
+pdfDocEncodingToUnicode[0x99] = toCharCode('\u017D'); // LATIN CAPITAL LETTER Z WITH CARON
+pdfDocEncodingToUnicode[0x9a] = toCharCode('\u0131'); // LATIN SMALL LETTER DOTLESS I
+pdfDocEncodingToUnicode[0x9b] = toCharCode('\u0142'); // LATIN SMALL LETTER L WITH STROKE
+pdfDocEncodingToUnicode[0x9c] = toCharCode('\u0153'); // LATIN SMALL LIGATURE OE
+pdfDocEncodingToUnicode[0x9d] = toCharCode('\u0161'); // LATIN SMALL LETTER S WITH CARON
+pdfDocEncodingToUnicode[0x9e] = toCharCode('\u017E'); // LATIN SMALL LETTER Z WITH CARON
+pdfDocEncodingToUnicode[0x9f] = toCharCode('\uFFFD'); // REPLACEMENT CHARACTER (box with questionmark)
+pdfDocEncodingToUnicode[0xa0] = toCharCode('\u20AC'); // EURO SIGN
+pdfDocEncodingToUnicode[0xad] = toCharCode('\uFFFD'); // REPLACEMENT CHARACTER (box with questionmark)
+/**
+ * Decode a byte array into a string using PDFDocEncoding.
+ *
+ * @param bytes a byte array (decimal representation) containing a string
+ *              encoded with PDFDocEncoding.
+ */
+var pdfDocEncodingDecode = function (bytes) {
+    var codePoints = new Array(bytes.length);
+    for (var idx = 0, len = bytes.length; idx < len; idx++) {
+        codePoints[idx] = pdfDocEncodingToUnicode[bytes[idx]];
+    }
+    return String.fromCodePoint.apply(String, codePoints);
+};
+
+export { pdfDocEncodingDecode };