art-bd-ui 1.0.21 → 1.0.23

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

@@ -0,0 +1,209 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+var tslib_es6 = require('../../../tslib/tslib.es6.js');
+var index = require('../../../../_virtual/index8.js');
+var PDFHeader = require('./document/PDFHeader.js');
+var errors = require('./errors.js');
+var PDFArray = require('./objects/PDFArray.js');
+var PDFBool = require('./objects/PDFBool.js');
+var PDFDict = require('./objects/PDFDict.js');
+var PDFName = require('./objects/PDFName.js');
+var PDFNull = require('./objects/PDFNull.js');
+var PDFNumber = require('./objects/PDFNumber.js');
+var PDFObject = require('./objects/PDFObject.js');
+var PDFRawStream = require('./objects/PDFRawStream.js');
+var PDFRef = require('./objects/PDFRef.js');
+var PDFOperator = require('./operators/PDFOperator.js');
+var PDFOperatorNames = require('./operators/PDFOperatorNames.js');
+var PDFContentStream = require('./structures/PDFContentStream.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 rng = require('../utils/rng.js');
+
+var byAscendingObjectNumber = function (_a, _b) {
+    var a = _a[0];
+    var b = _b[0];
+    return a.objectNumber - b.objectNumber;
+};
+var PDFContext = /** @class */ (function () {
+    function PDFContext() {
+        this.largestObjectNumber = 0;
+        this.header = PDFHeader.default.forVersion(1, 7);
+        this.trailerInfo = {};
+        this.indirectObjects = new Map();
+        this.rng = rng.SimpleRNG.withSeed(1);
+    }
+    PDFContext.prototype.assign = function (ref, object) {
+        this.indirectObjects.set(ref, object);
+        if (ref.objectNumber > this.largestObjectNumber) {
+            this.largestObjectNumber = ref.objectNumber;
+        }
+    };
+    PDFContext.prototype.nextRef = function () {
+        this.largestObjectNumber += 1;
+        return PDFRef.default.of(this.largestObjectNumber);
+    };
+    PDFContext.prototype.register = function (object) {
+        var ref = this.nextRef();
+        this.assign(ref, object);
+        return ref;
+    };
+    PDFContext.prototype.delete = function (ref) {
+        return this.indirectObjects.delete(ref);
+    };
+    PDFContext.prototype.lookupMaybe = function (ref) {
+        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 result = ref instanceof PDFRef.default ? this.indirectObjects.get(ref) : ref;
+        if (!result || (result === PDFNull.default && !preservePDFNull))
+            return undefined;
+        for (var idx = 0, len = types.length; idx < len; idx++) {
+            var type = types[idx];
+            if (type === PDFNull.default) {
+                if (result === PDFNull.default)
+                    return result;
+            }
+            else {
+                if (result instanceof type)
+                    return result;
+            }
+        }
+        throw new errors.UnexpectedObjectTypeError(types, result);
+    };
+    PDFContext.prototype.lookup = function (ref) {
+        var types = [];
+        for (var _i = 1; _i < arguments.length; _i++) {
+            types[_i - 1] = arguments[_i];
+        }
+        var result = ref instanceof PDFRef.default ? this.indirectObjects.get(ref) : ref;
+        if (types.length === 0)
+            return result;
+        for (var idx = 0, len = types.length; idx < len; idx++) {
+            var type = types[idx];
+            if (type === PDFNull.default) {
+                if (result === PDFNull.default)
+                    return result;
+            }
+            else {
+                if (result instanceof type)
+                    return result;
+            }
+        }
+        throw new errors.UnexpectedObjectTypeError(types, result);
+    };
+    PDFContext.prototype.getObjectRef = function (pdfObject) {
+        var entries = Array.from(this.indirectObjects.entries());
+        for (var idx = 0, len = entries.length; idx < len; idx++) {
+            var _a = entries[idx], ref = _a[0], object = _a[1];
+            if (object === pdfObject) {
+                return ref;
+            }
+        }
+        return undefined;
+    };
+    PDFContext.prototype.enumerateIndirectObjects = function () {
+        return Array.from(this.indirectObjects.entries()).sort(byAscendingObjectNumber);
+    };
+    PDFContext.prototype.obj = function (literal) {
+        if (literal instanceof PDFObject.default) {
+            return literal;
+        }
+        else if (literal === null || literal === undefined) {
+            return PDFNull.default;
+        }
+        else if (typeof literal === 'string') {
+            return PDFName.default.of(literal);
+        }
+        else if (typeof literal === 'number') {
+            return PDFNumber.default.of(literal);
+        }
+        else if (typeof literal === 'boolean') {
+            return literal ? PDFBool.default.True : PDFBool.default.False;
+        }
+        else if (Array.isArray(literal)) {
+            var array = PDFArray.default.withContext(this);
+            for (var idx = 0, len = literal.length; idx < len; idx++) {
+                array.push(this.obj(literal[idx]));
+            }
+            return array;
+        }
+        else {
+            var dict = PDFDict.default.withContext(this);
+            var keys = Object.keys(literal);
+            for (var idx = 0, len = keys.length; idx < len; idx++) {
+                var key = keys[idx];
+                var value = literal[key];
+                if (value !== undefined)
+                    dict.set(PDFName.default.of(key), this.obj(value));
+            }
+            return dict;
+        }
+    };
+    PDFContext.prototype.stream = function (contents, dict) {
+        if (dict === void 0) { dict = {}; }
+        return PDFRawStream.default.of(this.obj(dict), arrays.typedArrayFor(contents));
+    };
+    PDFContext.prototype.flateStream = function (contents, dict) {
+        if (dict === void 0) { dict = {}; }
+        return this.stream(index.default.deflate(arrays.typedArrayFor(contents)), tslib_es6.__assign(tslib_es6.__assign({}, dict), { Filter: 'FlateDecode' }));
+    };
+    PDFContext.prototype.contentStream = function (operators, dict) {
+        if (dict === void 0) { dict = {}; }
+        return PDFContentStream.default.of(this.obj(dict), operators);
+    };
+    PDFContext.prototype.formXObject = function (operators, dict) {
+        if (dict === void 0) { dict = {}; }
+        return this.contentStream(operators, tslib_es6.__assign(tslib_es6.__assign({ BBox: this.obj([0, 0, 0, 0]), Matrix: this.obj([1, 0, 0, 1, 0, 0]) }, dict), { Type: 'XObject', Subtype: 'Form' }));
+    };
+    /*
+     * Reference to PDFContentStream that contains a single PDFOperator: `q`.
+     * Used by [[PDFPageLeaf]] instances to ensure that when content streams are
+     * added to a modified PDF, they start in the default, unchanged graphics
+     * state.
+     */
+    PDFContext.prototype.getPushGraphicsStateContentStream = function () {
+        if (this.pushGraphicsStateContentStreamRef) {
+            return this.pushGraphicsStateContentStreamRef;
+        }
+        var dict = this.obj({});
+        var op = PDFOperator.default.of(PDFOperatorNames.default.PushGraphicsState);
+        var stream = PDFContentStream.default.of(dict, [op]);
+        this.pushGraphicsStateContentStreamRef = this.register(stream);
+        return this.pushGraphicsStateContentStreamRef;
+    };
+    /*
+     * Reference to PDFContentStream that contains a single PDFOperator: `Q`.
+     * Used by [[PDFPageLeaf]] instances to ensure that when content streams are
+     * added to a modified PDF, they start in the default, unchanged graphics
+     * state.
+     */
+    PDFContext.prototype.getPopGraphicsStateContentStream = function () {
+        if (this.popGraphicsStateContentStreamRef) {
+            return this.popGraphicsStateContentStreamRef;
+        }
+        var dict = this.obj({});
+        var op = PDFOperator.default.of(PDFOperatorNames.default.PopGraphicsState);
+        var stream = PDFContentStream.default.of(dict, [op]);
+        this.popGraphicsStateContentStreamRef = this.register(stream);
+        return this.popGraphicsStateContentStreamRef;
+    };
+    PDFContext.prototype.addRandomSuffix = function (prefix, suffixLength) {
+        if (suffixLength === void 0) { suffixLength = 4; }
+        return prefix + "-" + Math.floor(this.rng.nextInt() * Math.pow(10, suffixLength));
+    };
+    PDFContext.create = function () { return new PDFContext(); };
+    return PDFContext;
+}());
+
+exports.default = PDFContext;

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

@@ -0,0 +1,121 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+var PDFArray = require('./objects/PDFArray.js');
+var PDFDict = require('./objects/PDFDict.js');
+var PDFName = require('./objects/PDFName.js');
+var PDFRef = require('./objects/PDFRef.js');
+var PDFStream = require('./objects/PDFStream.js');
+var PDFPageLeaf = require('./structures/PDFPageLeaf.js');
+
+/**
+ * PDFObjectCopier copies PDFObjects from a src context to a dest context.
+ * The primary use case for this is to copy pages between PDFs.
+ *
+ * _Copying_ an object with a PDFObjectCopier is different from _cloning_ an
+ * object with its [[PDFObject.clone]] method:
+ *
+ * ```
+ *   const src: PDFContext = ...
+ *   const dest: PDFContext = ...
+ *   const originalObject: PDFObject = ...
+ *   const copiedObject = PDFObjectCopier.for(src, dest).copy(originalObject);
+ *   const clonedObject = originalObject.clone();
+ * ```
+ *
+ * Copying an object is equivalent to cloning it and then copying over any other
+ * objects that it references. Note that only dictionaries, arrays, and streams
+ * (or structures build from them) can contain indirect references to other
+ * objects. Copying a PDFObject that is not a dictionary, array, or stream is
+ * supported, but is equivalent to cloning it.
+ */
+var PDFObjectCopier = /** @class */ (function () {
+    function PDFObjectCopier(src, dest) {
+        var _this = this;
+        this.traversedObjects = new Map();
+        // prettier-ignore
+        this.copy = function (object) { return (object instanceof PDFPageLeaf.default ? _this.copyPDFPage(object)
+            : object instanceof PDFDict.default ? _this.copyPDFDict(object)
+                : object instanceof PDFArray.default ? _this.copyPDFArray(object)
+                    : object instanceof PDFStream.default ? _this.copyPDFStream(object)
+                        : object instanceof PDFRef.default ? _this.copyPDFIndirectObject(object)
+                            : object.clone()); };
+        this.copyPDFPage = function (originalPage) {
+            var clonedPage = originalPage.clone();
+            // Move any entries that the originalPage is inheriting from its parent
+            // tree nodes directly into originalPage so they are preserved during
+            // the copy.
+            var InheritableEntries = PDFPageLeaf.default.InheritableEntries;
+            for (var idx = 0, len = InheritableEntries.length; idx < len; idx++) {
+                var key = PDFName.default.of(InheritableEntries[idx]);
+                var value = clonedPage.getInheritableAttribute(key);
+                if (!clonedPage.get(key) && value)
+                    clonedPage.set(key, value);
+            }
+            // Remove the parent reference to prevent the whole donor document's page
+            // tree from being copied when we only need a single page.
+            clonedPage.delete(PDFName.default.of('Parent'));
+            return _this.copyPDFDict(clonedPage);
+        };
+        this.copyPDFDict = function (originalDict) {
+            if (_this.traversedObjects.has(originalDict)) {
+                return _this.traversedObjects.get(originalDict);
+            }
+            var clonedDict = originalDict.clone(_this.dest);
+            _this.traversedObjects.set(originalDict, clonedDict);
+            var entries = originalDict.entries();
+            for (var idx = 0, len = entries.length; idx < len; idx++) {
+                var _a = entries[idx], key = _a[0], value = _a[1];
+                clonedDict.set(key, _this.copy(value));
+            }
+            return clonedDict;
+        };
+        this.copyPDFArray = function (originalArray) {
+            if (_this.traversedObjects.has(originalArray)) {
+                return _this.traversedObjects.get(originalArray);
+            }
+            var clonedArray = originalArray.clone(_this.dest);
+            _this.traversedObjects.set(originalArray, clonedArray);
+            for (var idx = 0, len = originalArray.size(); idx < len; idx++) {
+                var value = originalArray.get(idx);
+                clonedArray.set(idx, _this.copy(value));
+            }
+            return clonedArray;
+        };
+        this.copyPDFStream = function (originalStream) {
+            if (_this.traversedObjects.has(originalStream)) {
+                return _this.traversedObjects.get(originalStream);
+            }
+            var clonedStream = originalStream.clone(_this.dest);
+            _this.traversedObjects.set(originalStream, clonedStream);
+            var entries = originalStream.dict.entries();
+            for (var idx = 0, len = entries.length; idx < len; idx++) {
+                var _a = entries[idx], key = _a[0], value = _a[1];
+                clonedStream.dict.set(key, _this.copy(value));
+            }
+            return clonedStream;
+        };
+        this.copyPDFIndirectObject = function (ref) {
+            var alreadyMapped = _this.traversedObjects.has(ref);
+            if (!alreadyMapped) {
+                var newRef = _this.dest.nextRef();
+                _this.traversedObjects.set(ref, newRef);
+                var dereferencedValue = _this.src.lookup(ref);
+                if (dereferencedValue) {
+                    var cloned = _this.copy(dereferencedValue);
+                    _this.dest.assign(newRef, cloned);
+                }
+            }
+            return _this.traversedObjects.get(ref);
+        };
+        this.src = src;
+        this.dest = dest;
+    }
+    PDFObjectCopier.for = function (src, dest) {
+        return new PDFObjectCopier(src, dest);
+    };
+    return PDFObjectCopier;
+}());
+
+exports.default = PDFObjectCopier;

package/dist/cjs/node_modules/pdf-lib/es/core/acroform/PDFAcroButton.js

@@ -0,0 +1,99 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+var tslib_es6 = require('../../../../tslib/tslib.es6.js');
+var PDFString = require('../objects/PDFString.js');
+var PDFHexString = require('../objects/PDFHexString.js');
+var PDFArray = require('../objects/PDFArray.js');
+var PDFName = require('../objects/PDFName.js');
+var PDFAcroTerminal = require('./PDFAcroTerminal.js');
+var errors = require('../errors.js');
+
+var PDFAcroButton = /** @class */ (function (_super) {
+    tslib_es6.__extends(PDFAcroButton, _super);
+    function PDFAcroButton() {
+        return _super !== null && _super.apply(this, arguments) || this;
+    }
+    PDFAcroButton.prototype.Opt = function () {
+        return this.dict.lookupMaybe(PDFName.default.of('Opt'), PDFString.default, PDFHexString.default, PDFArray.default);
+    };
+    PDFAcroButton.prototype.setOpt = function (opt) {
+        this.dict.set(PDFName.default.of('Opt'), this.dict.context.obj(opt));
+    };
+    PDFAcroButton.prototype.getExportValues = function () {
+        var opt = this.Opt();
+        if (!opt)
+            return undefined;
+        if (opt instanceof PDFString.default || opt instanceof PDFHexString.default) {
+            return [opt];
+        }
+        var values = [];
+        for (var idx = 0, len = opt.size(); idx < len; idx++) {
+            var value = opt.lookup(idx);
+            if (value instanceof PDFString.default || value instanceof PDFHexString.default) {
+                values.push(value);
+            }
+        }
+        return values;
+    };
+    PDFAcroButton.prototype.removeExportValue = function (idx) {
+        var opt = this.Opt();
+        if (!opt)
+            return;
+        if (opt instanceof PDFString.default || opt instanceof PDFHexString.default) {
+            if (idx !== 0)
+                throw new errors.IndexOutOfBoundsError(idx, 0, 0);
+            this.setOpt([]);
+        }
+        else {
+            if (idx < 0 || idx > opt.size()) {
+                throw new errors.IndexOutOfBoundsError(idx, 0, opt.size());
+            }
+            opt.remove(idx);
+        }
+    };
+    // Enforce use use of /Opt even if it isn't strictly necessary
+    PDFAcroButton.prototype.normalizeExportValues = function () {
+        var _a, _b, _c, _d;
+        var exportValues = (_a = this.getExportValues()) !== null && _a !== void 0 ? _a : [];
+        var Opt = [];
+        var widgets = this.getWidgets();
+        for (var idx = 0, len = widgets.length; idx < len; idx++) {
+            var widget = widgets[idx];
+            var exportVal = (_b = exportValues[idx]) !== null && _b !== void 0 ? _b : PDFHexString.default.fromText((_d = (_c = widget.getOnValue()) === null || _c === void 0 ? void 0 : _c.decodeText()) !== null && _d !== void 0 ? _d : '');
+            Opt.push(exportVal);
+        }
+        this.setOpt(Opt);
+    };
+    /**
+     * Reuses existing opt if one exists with the same value (assuming
+     * `useExistingIdx` is `true`). Returns index of existing (or new) opt.
+     */
+    PDFAcroButton.prototype.addOpt = function (opt, useExistingOptIdx) {
+        var _a;
+        this.normalizeExportValues();
+        var optText = opt.decodeText();
+        var existingIdx;
+        if (useExistingOptIdx) {
+            var exportValues = (_a = this.getExportValues()) !== null && _a !== void 0 ? _a : [];
+            for (var idx = 0, len = exportValues.length; idx < len; idx++) {
+                var exportVal = exportValues[idx];
+                if (exportVal.decodeText() === optText)
+                    existingIdx = idx;
+            }
+        }
+        var Opt = this.Opt();
+        Opt.push(opt);
+        return existingIdx !== null && existingIdx !== void 0 ? existingIdx : Opt.size() - 1;
+    };
+    PDFAcroButton.prototype.addWidgetWithOpt = function (widget, opt, useExistingOptIdx) {
+        var optIdx = this.addOpt(opt, useExistingOptIdx);
+        var apStateValue = PDFName.default.of(String(optIdx));
+        this.addWidget(widget);
+        return apStateValue;
+    };
+    return PDFAcroButton;
+}(PDFAcroTerminal.default));
+
+exports.default = PDFAcroButton;

package/dist/cjs/node_modules/pdf-lib/es/core/acroform/PDFAcroCheckBox.js

@@ -0,0 +1,53 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+var tslib_es6 = require('../../../../tslib/tslib.es6.js');
+var PDFName = require('../objects/PDFName.js');
+var PDFAcroButton = require('./PDFAcroButton.js');
+var errors = require('../errors.js');
+
+var PDFAcroCheckBox = /** @class */ (function (_super) {
+    tslib_es6.__extends(PDFAcroCheckBox, _super);
+    function PDFAcroCheckBox() {
+        return _super !== null && _super.apply(this, arguments) || this;
+    }
+    PDFAcroCheckBox.prototype.setValue = function (value) {
+        var _a;
+        var onValue = (_a = this.getOnValue()) !== null && _a !== void 0 ? _a : PDFName.default.of('Yes');
+        if (value !== onValue && value !== PDFName.default.of('Off')) {
+            throw new errors.InvalidAcroFieldValueError();
+        }
+        this.dict.set(PDFName.default.of('V'), value);
+        var widgets = this.getWidgets();
+        for (var idx = 0, len = widgets.length; idx < len; idx++) {
+            var widget = widgets[idx];
+            var state = widget.getOnValue() === value ? value : PDFName.default.of('Off');
+            widget.setAppearanceState(state);
+        }
+    };
+    PDFAcroCheckBox.prototype.getValue = function () {
+        var v = this.V();
+        if (v instanceof PDFName.default)
+            return v;
+        return PDFName.default.of('Off');
+    };
+    PDFAcroCheckBox.prototype.getOnValue = function () {
+        var widget = this.getWidgets()[0];
+        return widget === null || widget === void 0 ? void 0 : widget.getOnValue();
+    };
+    PDFAcroCheckBox.fromDict = function (dict, ref) {
+        return new PDFAcroCheckBox(dict, ref);
+    };
+    PDFAcroCheckBox.create = function (context) {
+        var dict = context.obj({
+            FT: 'Btn',
+            Kids: [],
+        });
+        var ref = context.register(dict);
+        return new PDFAcroCheckBox(dict, ref);
+    };
+    return PDFAcroCheckBox;
+}(PDFAcroButton.default));
+
+exports.default = PDFAcroCheckBox;

package/dist/cjs/node_modules/pdf-lib/es/core/acroform/PDFAcroChoice.js

@@ -0,0 +1,130 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+var tslib_es6 = require('../../../../tslib/tslib.es6.js');
+var PDFAcroTerminal = require('./PDFAcroTerminal.js');
+var PDFHexString = require('../objects/PDFHexString.js');
+var PDFString = require('../objects/PDFString.js');
+var PDFArray = require('../objects/PDFArray.js');
+var PDFName = require('../objects/PDFName.js');
+var flags = require('./flags.js');
+var errors = require('../errors.js');
+
+var PDFAcroChoice = /** @class */ (function (_super) {
+    tslib_es6.__extends(PDFAcroChoice, _super);
+    function PDFAcroChoice() {
+        return _super !== null && _super.apply(this, arguments) || this;
+    }
+    PDFAcroChoice.prototype.setValues = function (values) {
+        if (this.hasFlag(flags.AcroChoiceFlags.Combo) &&
+            !this.hasFlag(flags.AcroChoiceFlags.Edit) &&
+            !this.valuesAreValid(values)) {
+            throw new errors.InvalidAcroFieldValueError();
+        }
+        if (values.length === 0) {
+            this.dict.delete(PDFName.default.of('V'));
+        }
+        if (values.length === 1) {
+            this.dict.set(PDFName.default.of('V'), values[0]);
+        }
+        if (values.length > 1) {
+            if (!this.hasFlag(flags.AcroChoiceFlags.MultiSelect)) {
+                throw new errors.MultiSelectValueError();
+            }
+            this.dict.set(PDFName.default.of('V'), this.dict.context.obj(values));
+        }
+        this.updateSelectedIndices(values);
+    };
+    PDFAcroChoice.prototype.valuesAreValid = function (values) {
+        var options = this.getOptions();
+        var _loop_1 = function (idx, len) {
+            var val = values[idx].decodeText();
+            if (!options.find(function (o) { return val === (o.display || o.value).decodeText(); })) {
+                return { value: false };
+            }
+        };
+        for (var idx = 0, len = values.length; idx < len; idx++) {
+            var state_1 = _loop_1(idx);
+            if (typeof state_1 === "object")
+                return state_1.value;
+        }
+        return true;
+    };
+    PDFAcroChoice.prototype.updateSelectedIndices = function (values) {
+        if (values.length > 1) {
+            var indices = new Array(values.length);
+            var options = this.getOptions();
+            var _loop_2 = function (idx, len) {
+                var val = values[idx].decodeText();
+                indices[idx] = options.findIndex(function (o) { return val === (o.display || o.value).decodeText(); });
+            };
+            for (var idx = 0, len = values.length; idx < len; idx++) {
+                _loop_2(idx, len);
+            }
+            this.dict.set(PDFName.default.of('I'), this.dict.context.obj(indices.sort()));
+        }
+        else {
+            this.dict.delete(PDFName.default.of('I'));
+        }
+    };
+    PDFAcroChoice.prototype.getValues = function () {
+        var v = this.V();
+        if (v instanceof PDFString.default || v instanceof PDFHexString.default)
+            return [v];
+        if (v instanceof PDFArray.default) {
+            var values = [];
+            for (var idx = 0, len = v.size(); idx < len; idx++) {
+                var value = v.lookup(idx);
+                if (value instanceof PDFString.default || value instanceof PDFHexString.default) {
+                    values.push(value);
+                }
+            }
+            return values;
+        }
+        return [];
+    };
+    PDFAcroChoice.prototype.Opt = function () {
+        return this.dict.lookupMaybe(PDFName.default.of('Opt'), PDFString.default, PDFHexString.default, PDFArray.default);
+    };
+    PDFAcroChoice.prototype.setOptions = function (options) {
+        var newOpt = new Array(options.length);
+        for (var idx = 0, len = options.length; idx < len; idx++) {
+            var _a = options[idx], value = _a.value, display = _a.display;
+            newOpt[idx] = this.dict.context.obj([value, display || value]);
+        }
+        this.dict.set(PDFName.default.of('Opt'), this.dict.context.obj(newOpt));
+    };
+    PDFAcroChoice.prototype.getOptions = function () {
+        var Opt = this.Opt();
+        // Not supposed to happen - Opt _should_ always be `PDFArray | undefined`
+        if (Opt instanceof PDFString.default || Opt instanceof PDFHexString.default) {
+            return [{ value: Opt, display: Opt }];
+        }
+        if (Opt instanceof PDFArray.default) {
+            var res = [];
+            for (var idx = 0, len = Opt.size(); idx < len; idx++) {
+                var item = Opt.lookup(idx);
+                // If `item` is a string, use that as both the export and text value
+                if (item instanceof PDFString.default || item instanceof PDFHexString.default) {
+                    res.push({ value: item, display: item });
+                }
+                // If `item` is an array of one, treat it the same as just a string,
+                // if it's an array of two then `item[0]` is the export value and
+                // `item[1]` is the text value
+                if (item instanceof PDFArray.default) {
+                    if (item.size() > 0) {
+                        var first = item.lookup(0, PDFString.default, PDFHexString.default);
+                        var second = item.lookupMaybe(1, PDFString.default, PDFHexString.default);
+                        res.push({ value: first, display: second || first });
+                    }
+                }
+            }
+            return res;
+        }
+        return [];
+    };
+    return PDFAcroChoice;
+}(PDFAcroTerminal.default));
+
+exports.default = PDFAcroChoice;

package/dist/cjs/node_modules/pdf-lib/es/core/acroform/PDFAcroComboBox.js

@@ -0,0 +1,29 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+var tslib_es6 = require('../../../../tslib/tslib.es6.js');
+var PDFAcroChoice = require('./PDFAcroChoice.js');
+var flags = require('./flags.js');
+
+var PDFAcroComboBox = /** @class */ (function (_super) {
+    tslib_es6.__extends(PDFAcroComboBox, _super);
+    function PDFAcroComboBox() {
+        return _super !== null && _super.apply(this, arguments) || this;
+    }
+    PDFAcroComboBox.fromDict = function (dict, ref) {
+        return new PDFAcroComboBox(dict, ref);
+    };
+    PDFAcroComboBox.create = function (context) {
+        var dict = context.obj({
+            FT: 'Ch',
+            Ff: flags.AcroChoiceFlags.Combo,
+            Kids: [],
+        });
+        var ref = context.register(dict);
+        return new PDFAcroComboBox(dict, ref);
+    };
+    return PDFAcroComboBox;
+}(PDFAcroChoice.default));
+
+exports.default = PDFAcroComboBox;