art-bd-ui 1.0.21 → 1.0.23

package/dist/cjs/node_modules/pdf-lib/es/core/objects/PDFDict.js

@@ -0,0 +1,141 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+var tslib_es6 = require('../../../../tslib/tslib.es6.js');
+var PDFName = require('./PDFName.js');
+var PDFNull = require('./PDFNull.js');
+var PDFObject = require('./PDFObject.js');
+var CharCodes = require('../syntax/CharCodes.js');
+
+var PDFDict = /** @class */ (function (_super) {
+    tslib_es6.__extends(PDFDict, _super);
+    function PDFDict(map, context) {
+        var _this = _super.call(this) || this;
+        _this.dict = map;
+        _this.context = context;
+        return _this;
+    }
+    PDFDict.prototype.keys = function () {
+        return Array.from(this.dict.keys());
+    };
+    PDFDict.prototype.values = function () {
+        return Array.from(this.dict.values());
+    };
+    PDFDict.prototype.entries = function () {
+        return Array.from(this.dict.entries());
+    };
+    PDFDict.prototype.set = function (key, value) {
+        this.dict.set(key, value);
+    };
+    PDFDict.prototype.get = function (key, 
+    // TODO: `preservePDFNull` is for backwards compatibility. Should be
+    // removed in next breaking API change.
+    preservePDFNull) {
+        if (preservePDFNull === void 0) { preservePDFNull = false; }
+        var value = this.dict.get(key);
+        if (value === PDFNull.default && !preservePDFNull)
+            return undefined;
+        return value;
+    };
+    PDFDict.prototype.has = function (key) {
+        var value = this.dict.get(key);
+        return value !== undefined && value !== PDFNull.default;
+    };
+    PDFDict.prototype.lookupMaybe = function (key) {
+        var _a;
+        var types = [];
+        for (var _i = 1; _i < arguments.length; _i++) {
+            types[_i - 1] = arguments[_i];
+        }
+        // TODO: `preservePDFNull` is for backwards compatibility. Should be
+        // removed in next breaking API change.
+        var preservePDFNull = types.includes(PDFNull.default);
+        var value = (_a = this.context).lookupMaybe.apply(_a, tslib_es6.__spreadArrays([this.get(key, preservePDFNull)], types));
+        if (value === PDFNull.default && !preservePDFNull)
+            return undefined;
+        return value;
+    };
+    PDFDict.prototype.lookup = function (key) {
+        var _a;
+        var types = [];
+        for (var _i = 1; _i < arguments.length; _i++) {
+            types[_i - 1] = arguments[_i];
+        }
+        // TODO: `preservePDFNull` is for backwards compatibility. Should be
+        // removed in next breaking API change.
+        var preservePDFNull = types.includes(PDFNull.default);
+        var value = (_a = this.context).lookup.apply(_a, tslib_es6.__spreadArrays([this.get(key, preservePDFNull)], types));
+        if (value === PDFNull.default && !preservePDFNull)
+            return undefined;
+        return value;
+    };
+    PDFDict.prototype.delete = function (key) {
+        return this.dict.delete(key);
+    };
+    PDFDict.prototype.asMap = function () {
+        return new Map(this.dict);
+    };
+    /** Generate a random key that doesn't exist in current key set */
+    PDFDict.prototype.uniqueKey = function (tag) {
+        if (tag === void 0) { tag = ''; }
+        var existingKeys = this.keys();
+        var key = PDFName.default.of(this.context.addRandomSuffix(tag, 10));
+        while (existingKeys.includes(key)) {
+            key = PDFName.default.of(this.context.addRandomSuffix(tag, 10));
+        }
+        return key;
+    };
+    PDFDict.prototype.clone = function (context) {
+        var clone = PDFDict.withContext(context || this.context);
+        var entries = this.entries();
+        for (var idx = 0, len = entries.length; idx < len; idx++) {
+            var _a = entries[idx], key = _a[0], value = _a[1];
+            clone.set(key, value);
+        }
+        return clone;
+    };
+    PDFDict.prototype.toString = function () {
+        var dictString = '<<\n';
+        var entries = this.entries();
+        for (var idx = 0, len = entries.length; idx < len; idx++) {
+            var _a = entries[idx], key = _a[0], value = _a[1];
+            dictString += key.toString() + ' ' + value.toString() + '\n';
+        }
+        dictString += '>>';
+        return dictString;
+    };
+    PDFDict.prototype.sizeInBytes = function () {
+        var size = 5;
+        var entries = this.entries();
+        for (var idx = 0, len = entries.length; idx < len; idx++) {
+            var _a = entries[idx], key = _a[0], value = _a[1];
+            size += key.sizeInBytes() + value.sizeInBytes() + 2;
+        }
+        return size;
+    };
+    PDFDict.prototype.copyBytesInto = function (buffer, offset) {
+        var initialOffset = offset;
+        buffer[offset++] = CharCodes.default.LessThan;
+        buffer[offset++] = CharCodes.default.LessThan;
+        buffer[offset++] = CharCodes.default.Newline;
+        var entries = this.entries();
+        for (var idx = 0, len = entries.length; idx < len; idx++) {
+            var _a = entries[idx], key = _a[0], value = _a[1];
+            offset += key.copyBytesInto(buffer, offset);
+            buffer[offset++] = CharCodes.default.Space;
+            offset += value.copyBytesInto(buffer, offset);
+            buffer[offset++] = CharCodes.default.Newline;
+        }
+        buffer[offset++] = CharCodes.default.GreaterThan;
+        buffer[offset++] = CharCodes.default.GreaterThan;
+        return offset - initialOffset;
+    };
+    PDFDict.withContext = function (context) { return new PDFDict(new Map(), context); };
+    PDFDict.fromMapWithContext = function (map, context) {
+        return new PDFDict(map, context);
+    };
+    return PDFDict;
+}(PDFObject.default));
+
+exports.default = PDFDict;

package/dist/cjs/node_modules/pdf-lib/es/core/objects/PDFHexString.js

@@ -0,0 +1,82 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+var tslib_es6 = require('../../../../tslib/tslib.es6.js');
+var PDFObject = require('./PDFObject.js');
+var CharCodes = require('../syntax/CharCodes.js');
+require('../../utils/base64.js');
+var strings = require('../../utils/strings.js');
+var unicode = require('../../utils/unicode.js');
+require('../../utils/objects.js');
+var pdfDocEncoding = require('../../utils/pdfDocEncoding.js');
+require('../../utils/Cache.js');
+var errors = require('../errors.js');
+
+var PDFHexString = /** @class */ (function (_super) {
+    tslib_es6.__extends(PDFHexString, _super);
+    function PDFHexString(value) {
+        var _this = _super.call(this) || this;
+        _this.value = value;
+        return _this;
+    }
+    PDFHexString.prototype.asBytes = function () {
+        // Append a zero if the number of digits is odd. See PDF spec 7.3.4.3
+        var hex = this.value + (this.value.length % 2 === 1 ? '0' : '');
+        var hexLength = hex.length;
+        var bytes = new Uint8Array(hex.length / 2);
+        var hexOffset = 0;
+        var bytesOffset = 0;
+        // Interpret each pair of hex digits as a single byte
+        while (hexOffset < hexLength) {
+            var byte = parseInt(hex.substring(hexOffset, hexOffset + 2), 16);
+            bytes[bytesOffset] = byte;
+            hexOffset += 2;
+            bytesOffset += 1;
+        }
+        return bytes;
+    };
+    PDFHexString.prototype.decodeText = function () {
+        var bytes = this.asBytes();
+        if (unicode.hasUtf16BOM(bytes))
+            return unicode.utf16Decode(bytes);
+        return pdfDocEncoding.pdfDocEncodingDecode(bytes);
+    };
+    PDFHexString.prototype.decodeDate = function () {
+        var text = this.decodeText();
+        var date = strings.parseDate(text);
+        if (!date)
+            throw new errors.InvalidPDFDateStringError(text);
+        return date;
+    };
+    PDFHexString.prototype.asString = function () {
+        return this.value;
+    };
+    PDFHexString.prototype.clone = function () {
+        return PDFHexString.of(this.value);
+    };
+    PDFHexString.prototype.toString = function () {
+        return "<" + this.value + ">";
+    };
+    PDFHexString.prototype.sizeInBytes = function () {
+        return this.value.length + 2;
+    };
+    PDFHexString.prototype.copyBytesInto = function (buffer, offset) {
+        buffer[offset++] = CharCodes.default.LessThan;
+        offset += strings.copyStringIntoBuffer(this.value, buffer, offset);
+        buffer[offset++] = CharCodes.default.GreaterThan;
+        return this.value.length + 2;
+    };
+    PDFHexString.of = function (value) { return new PDFHexString(value); };
+    PDFHexString.fromText = function (value) {
+        var encoded = unicode.utf16Encode(value);
+        var hex = '';
+        for (var idx = 0, len = encoded.length; idx < len; idx++) {
+            hex += strings.toHexStringOfMinLength(encoded[idx], 4);
+        }
+        return new PDFHexString(hex);
+    };
+    return PDFHexString;
+}(PDFObject.default));
+
+exports.default = PDFHexString;

package/dist/cjs/node_modules/pdf-lib/es/core/objects/PDFInvalidObject.js

@@ -0,0 +1,35 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+var tslib_es6 = require('../../../../tslib/tslib.es6.js');
+var PDFObject = require('./PDFObject.js');
+
+var PDFInvalidObject = /** @class */ (function (_super) {
+    tslib_es6.__extends(PDFInvalidObject, _super);
+    function PDFInvalidObject(data) {
+        var _this = _super.call(this) || this;
+        _this.data = data;
+        return _this;
+    }
+    PDFInvalidObject.prototype.clone = function () {
+        return PDFInvalidObject.of(this.data.slice());
+    };
+    PDFInvalidObject.prototype.toString = function () {
+        return "PDFInvalidObject(" + this.data.length + " bytes)";
+    };
+    PDFInvalidObject.prototype.sizeInBytes = function () {
+        return this.data.length;
+    };
+    PDFInvalidObject.prototype.copyBytesInto = function (buffer, offset) {
+        var length = this.data.length;
+        for (var idx = 0; idx < length; idx++) {
+            buffer[offset++] = this.data[idx];
+        }
+        return length;
+    };
+    PDFInvalidObject.of = function (data) { return new PDFInvalidObject(data); };
+    return PDFInvalidObject;
+}(PDFObject.default));
+
+exports.default = PDFInvalidObject;

package/dist/cjs/node_modules/pdf-lib/es/core/objects/PDFName.js

@@ -0,0 +1,146 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+var tslib_es6 = require('../../../../tslib/tslib.es6.js');
+var errors = require('../errors.js');
+var PDFObject = require('./PDFObject.js');
+var CharCodes = require('../syntax/CharCodes.js');
+var Irregular = require('../syntax/Irregular.js');
+require('../../utils/base64.js');
+var strings = require('../../utils/strings.js');
+require('../../utils/unicode.js');
+require('../../utils/objects.js');
+require('../../utils/pdfDocEncoding.js');
+require('../../utils/Cache.js');
+
+var decodeName = function (name) {
+    return name.replace(/#([\dABCDEF]{2})/g, function (_, hex) { return strings.charFromHexCode(hex); });
+};
+var isRegularChar = function (charCode) {
+    return charCode >= CharCodes.default.ExclamationPoint &&
+        charCode <= CharCodes.default.Tilde &&
+        !Irregular.IsIrregular[charCode];
+};
+var ENFORCER = {};
+var pool = new Map();
+var PDFName = /** @class */ (function (_super) {
+    tslib_es6.__extends(PDFName, _super);
+    function PDFName(enforcer, name) {
+        var _this = this;
+        if (enforcer !== ENFORCER)
+            throw new errors.PrivateConstructorError('PDFName');
+        _this = _super.call(this) || this;
+        var encodedName = '/';
+        for (var idx = 0, len = name.length; idx < len; idx++) {
+            var character = name[idx];
+            var code = strings.toCharCode(character);
+            encodedName += isRegularChar(code) ? character : "#" + strings.toHexString(code);
+        }
+        _this.encodedName = encodedName;
+        return _this;
+    }
+    PDFName.prototype.asBytes = function () {
+        var bytes = [];
+        var hex = '';
+        var escaped = false;
+        var pushByte = function (byte) {
+            if (byte !== undefined)
+                bytes.push(byte);
+            escaped = false;
+        };
+        for (var idx = 1, len = this.encodedName.length; idx < len; idx++) {
+            var char = this.encodedName[idx];
+            var byte = strings.toCharCode(char);
+            var nextChar = this.encodedName[idx + 1];
+            if (!escaped) {
+                if (byte === CharCodes.default.Hash)
+                    escaped = true;
+                else
+                    pushByte(byte);
+            }
+            else {
+                if ((byte >= CharCodes.default.Zero && byte <= CharCodes.default.Nine) ||
+                    (byte >= CharCodes.default.a && byte <= CharCodes.default.f) ||
+                    (byte >= CharCodes.default.A && byte <= CharCodes.default.F)) {
+                    hex += char;
+                    if (hex.length === 2 ||
+                        !((nextChar >= '0' && nextChar <= '9') ||
+                            (nextChar >= 'a' && nextChar <= 'f') ||
+                            (nextChar >= 'A' && nextChar <= 'F'))) {
+                        pushByte(parseInt(hex, 16));
+                        hex = '';
+                    }
+                }
+                else {
+                    pushByte(byte);
+                }
+            }
+        }
+        return new Uint8Array(bytes);
+    };
+    // TODO: This should probably use `utf8Decode()`
+    // TODO: Polyfill Array.from?
+    PDFName.prototype.decodeText = function () {
+        var bytes = this.asBytes();
+        return String.fromCharCode.apply(String, Array.from(bytes));
+    };
+    PDFName.prototype.asString = function () {
+        return this.encodedName;
+    };
+    /** @deprecated in favor of [[PDFName.asString]] */
+    PDFName.prototype.value = function () {
+        return this.encodedName;
+    };
+    PDFName.prototype.clone = function () {
+        return this;
+    };
+    PDFName.prototype.toString = function () {
+        return this.encodedName;
+    };
+    PDFName.prototype.sizeInBytes = function () {
+        return this.encodedName.length;
+    };
+    PDFName.prototype.copyBytesInto = function (buffer, offset) {
+        offset += strings.copyStringIntoBuffer(this.encodedName, buffer, offset);
+        return this.encodedName.length;
+    };
+    PDFName.of = function (name) {
+        var decodedValue = decodeName(name);
+        var instance = pool.get(decodedValue);
+        if (!instance) {
+            instance = new PDFName(ENFORCER, decodedValue);
+            pool.set(decodedValue, instance);
+        }
+        return instance;
+    };
+    /* tslint:disable member-ordering */
+    PDFName.Length = PDFName.of('Length');
+    PDFName.FlateDecode = PDFName.of('FlateDecode');
+    PDFName.Resources = PDFName.of('Resources');
+    PDFName.Font = PDFName.of('Font');
+    PDFName.XObject = PDFName.of('XObject');
+    PDFName.ExtGState = PDFName.of('ExtGState');
+    PDFName.Contents = PDFName.of('Contents');
+    PDFName.Type = PDFName.of('Type');
+    PDFName.Parent = PDFName.of('Parent');
+    PDFName.MediaBox = PDFName.of('MediaBox');
+    PDFName.Page = PDFName.of('Page');
+    PDFName.Annots = PDFName.of('Annots');
+    PDFName.TrimBox = PDFName.of('TrimBox');
+    PDFName.ArtBox = PDFName.of('ArtBox');
+    PDFName.BleedBox = PDFName.of('BleedBox');
+    PDFName.CropBox = PDFName.of('CropBox');
+    PDFName.Rotate = PDFName.of('Rotate');
+    PDFName.Title = PDFName.of('Title');
+    PDFName.Author = PDFName.of('Author');
+    PDFName.Subject = PDFName.of('Subject');
+    PDFName.Creator = PDFName.of('Creator');
+    PDFName.Keywords = PDFName.of('Keywords');
+    PDFName.Producer = PDFName.of('Producer');
+    PDFName.CreationDate = PDFName.of('CreationDate');
+    PDFName.ModDate = PDFName.of('ModDate');
+    return PDFName;
+}(PDFObject.default));
+
+exports.default = PDFName;

package/dist/cjs/node_modules/pdf-lib/es/core/objects/PDFNull.js

@@ -0,0 +1,37 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+var tslib_es6 = require('../../../../tslib/tslib.es6.js');
+var PDFObject = require('./PDFObject.js');
+var CharCodes = require('../syntax/CharCodes.js');
+
+var PDFNull = /** @class */ (function (_super) {
+    tslib_es6.__extends(PDFNull, _super);
+    function PDFNull() {
+        return _super !== null && _super.apply(this, arguments) || this;
+    }
+    PDFNull.prototype.asNull = function () {
+        return null;
+    };
+    PDFNull.prototype.clone = function () {
+        return this;
+    };
+    PDFNull.prototype.toString = function () {
+        return 'null';
+    };
+    PDFNull.prototype.sizeInBytes = function () {
+        return 4;
+    };
+    PDFNull.prototype.copyBytesInto = function (buffer, offset) {
+        buffer[offset++] = CharCodes.default.n;
+        buffer[offset++] = CharCodes.default.u;
+        buffer[offset++] = CharCodes.default.l;
+        buffer[offset++] = CharCodes.default.l;
+        return 4;
+    };
+    return PDFNull;
+}(PDFObject.default));
+var PDFNull$1 = new PDFNull();
+
+exports.default = PDFNull$1;

package/dist/cjs/node_modules/pdf-lib/es/core/objects/PDFNumber.js

@@ -0,0 +1,47 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+var tslib_es6 = require('../../../../tslib/tslib.es6.js');
+require('../../utils/base64.js');
+var strings = require('../../utils/strings.js');
+require('../../utils/unicode.js');
+var numbers = require('../../utils/numbers.js');
+require('../../utils/objects.js');
+require('../../utils/pdfDocEncoding.js');
+require('../../utils/Cache.js');
+var PDFObject = require('./PDFObject.js');
+
+var PDFNumber = /** @class */ (function (_super) {
+    tslib_es6.__extends(PDFNumber, _super);
+    function PDFNumber(value) {
+        var _this = _super.call(this) || this;
+        _this.numberValue = value;
+        _this.stringValue = numbers.numberToString(value);
+        return _this;
+    }
+    PDFNumber.prototype.asNumber = function () {
+        return this.numberValue;
+    };
+    /** @deprecated in favor of [[PDFNumber.asNumber]] */
+    PDFNumber.prototype.value = function () {
+        return this.numberValue;
+    };
+    PDFNumber.prototype.clone = function () {
+        return PDFNumber.of(this.numberValue);
+    };
+    PDFNumber.prototype.toString = function () {
+        return this.stringValue;
+    };
+    PDFNumber.prototype.sizeInBytes = function () {
+        return this.stringValue.length;
+    };
+    PDFNumber.prototype.copyBytesInto = function (buffer, offset) {
+        offset += strings.copyStringIntoBuffer(this.stringValue, buffer, offset);
+        return this.stringValue.length;
+    };
+    PDFNumber.of = function (value) { return new PDFNumber(value); };
+    return PDFNumber;
+}(PDFObject.default));
+
+exports.default = PDFNumber;

package/dist/cjs/node_modules/pdf-lib/es/core/objects/PDFObject.js

@@ -0,0 +1,25 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+var errors = require('../errors.js');
+
+var PDFObject = /** @class */ (function () {
+    function PDFObject() {
+    }
+    PDFObject.prototype.clone = function (_context) {
+        throw new errors.MethodNotImplementedError(this.constructor.name, 'clone');
+    };
+    PDFObject.prototype.toString = function () {
+        throw new errors.MethodNotImplementedError(this.constructor.name, 'toString');
+    };
+    PDFObject.prototype.sizeInBytes = function () {
+        throw new errors.MethodNotImplementedError(this.constructor.name, 'sizeInBytes');
+    };
+    PDFObject.prototype.copyBytesInto = function (_buffer, _offset) {
+        throw new errors.MethodNotImplementedError(this.constructor.name, 'copyBytesInto');
+    };
+    return PDFObject;
+}());
+
+exports.default = PDFObject;

package/dist/cjs/node_modules/pdf-lib/es/core/objects/PDFRawStream.js

@@ -0,0 +1,42 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+var tslib_es6 = require('../../../../tslib/tslib.es6.js');
+var PDFStream = require('./PDFStream.js');
+var arrays = require('../../utils/arrays.js');
+require('../../utils/unicode.js');
+require('../../utils/base64.js');
+require('../../utils/objects.js');
+require('../../utils/pdfDocEncoding.js');
+require('../../utils/Cache.js');
+
+var PDFRawStream = /** @class */ (function (_super) {
+    tslib_es6.__extends(PDFRawStream, _super);
+    function PDFRawStream(dict, contents) {
+        var _this = _super.call(this, dict) || this;
+        _this.contents = contents;
+        return _this;
+    }
+    PDFRawStream.prototype.asUint8Array = function () {
+        return this.contents.slice();
+    };
+    PDFRawStream.prototype.clone = function (context) {
+        return PDFRawStream.of(this.dict.clone(context), this.contents.slice());
+    };
+    PDFRawStream.prototype.getContentsString = function () {
+        return arrays.arrayAsString(this.contents);
+    };
+    PDFRawStream.prototype.getContents = function () {
+        return this.contents;
+    };
+    PDFRawStream.prototype.getContentsSize = function () {
+        return this.contents.length;
+    };
+    PDFRawStream.of = function (dict, contents) {
+        return new PDFRawStream(dict, contents);
+    };
+    return PDFRawStream;
+}(PDFStream.default));
+
+exports.default = PDFRawStream;

package/dist/cjs/node_modules/pdf-lib/es/core/objects/PDFRef.js

@@ -0,0 +1,55 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+var tslib_es6 = require('../../../../tslib/tslib.es6.js');
+var errors = require('../errors.js');
+var PDFObject = require('./PDFObject.js');
+require('../../utils/base64.js');
+var strings = require('../../utils/strings.js');
+require('../../utils/unicode.js');
+require('../../utils/objects.js');
+require('../../utils/pdfDocEncoding.js');
+require('../../utils/Cache.js');
+
+var ENFORCER = {};
+var pool = new Map();
+var PDFRef = /** @class */ (function (_super) {
+    tslib_es6.__extends(PDFRef, _super);
+    function PDFRef(enforcer, objectNumber, generationNumber) {
+        var _this = this;
+        if (enforcer !== ENFORCER)
+            throw new errors.PrivateConstructorError('PDFRef');
+        _this = _super.call(this) || this;
+        _this.objectNumber = objectNumber;
+        _this.generationNumber = generationNumber;
+        _this.tag = objectNumber + " " + generationNumber + " R";
+        return _this;
+    }
+    PDFRef.prototype.clone = function () {
+        return this;
+    };
+    PDFRef.prototype.toString = function () {
+        return this.tag;
+    };
+    PDFRef.prototype.sizeInBytes = function () {
+        return this.tag.length;
+    };
+    PDFRef.prototype.copyBytesInto = function (buffer, offset) {
+        offset += strings.copyStringIntoBuffer(this.tag, buffer, offset);
+        return this.tag.length;
+    };
+    PDFRef.of = function (objectNumber, generationNumber) {
+        if (generationNumber === void 0) { generationNumber = 0; }
+        var tag = objectNumber + " " + generationNumber + " R";
+        var instance = pool.get(tag);
+        if (!instance) {
+            instance = new PDFRef(ENFORCER, objectNumber, generationNumber);
+            pool.set(tag, instance);
+        }
+        return instance;
+    };
+    return PDFRef;
+}(PDFObject.default));
+
+exports.default = PDFRef;