art-bd-ui 1.0.21 → 1.0.23

package/dist/esm/node_modules/pdf-lib/es/api/text/alignment.js

@@ -0,0 +1,8 @@
+var TextAlignment;
+(function (TextAlignment) {
+    TextAlignment[TextAlignment["Left"] = 0] = "Left";
+    TextAlignment[TextAlignment["Center"] = 1] = "Center";
+    TextAlignment[TextAlignment["Right"] = 2] = "Right";
+})(TextAlignment || (TextAlignment = {}));
+
+export { TextAlignment };

package/dist/esm/node_modules/pdf-lib/es/api/text/layout.js

@@ -0,0 +1,216 @@
+import { CombedTextLayoutError } from '../errors.js';
+import { TextAlignment } from './alignment.js';
+import '../../utils/base64.js';
+import { mergeLines, cleanText, lineSplit, charAtIndex, charSplit } from '../../utils/strings.js';
+import '../../utils/unicode.js';
+import '../../utils/objects.js';
+import '../../utils/pdfDocEncoding.js';
+import '../../utils/Cache.js';
+
+var MIN_FONT_SIZE = 4;
+var MAX_FONT_SIZE = 500;
+var computeFontSize = function (lines, font, bounds, multiline) {
+    if (multiline === void 0) { multiline = false; }
+    var fontSize = MIN_FONT_SIZE;
+    while (fontSize < MAX_FONT_SIZE) {
+        var linesUsed = 0;
+        for (var lineIdx = 0, lineLen = lines.length; lineIdx < lineLen; lineIdx++) {
+            linesUsed += 1;
+            var line = lines[lineIdx];
+            var words = line.split(' ');
+            // Layout the words using the current `fontSize`, line wrapping
+            // whenever we reach the end of the current line.
+            var spaceInLineRemaining = bounds.width;
+            for (var idx = 0, len = words.length; idx < len; idx++) {
+                var isLastWord = idx === len - 1;
+                var word = isLastWord ? words[idx] : words[idx] + ' ';
+                var widthOfWord = font.widthOfTextAtSize(word, fontSize);
+                spaceInLineRemaining -= widthOfWord;
+                if (spaceInLineRemaining <= 0) {
+                    linesUsed += 1;
+                    spaceInLineRemaining = bounds.width - widthOfWord;
+                }
+            }
+        }
+        // Return if we exceeded the allowed width
+        if (!multiline && linesUsed > lines.length)
+            return fontSize - 1;
+        var height = font.heightAtSize(fontSize);
+        var lineHeight = height + height * 0.2;
+        var totalHeight = lineHeight * linesUsed;
+        // Return if we exceeded the allowed height
+        if (totalHeight > Math.abs(bounds.height))
+            return fontSize - 1;
+        fontSize += 1;
+    }
+    return fontSize;
+};
+var computeCombedFontSize = function (line, font, bounds, cellCount) {
+    var cellWidth = bounds.width / cellCount;
+    var cellHeight = bounds.height;
+    var fontSize = MIN_FONT_SIZE;
+    var chars = charSplit(line);
+    while (fontSize < MAX_FONT_SIZE) {
+        for (var idx = 0, len = chars.length; idx < len; idx++) {
+            var c = chars[idx];
+            var tooLong = font.widthOfTextAtSize(c, fontSize) > cellWidth * 0.75;
+            if (tooLong)
+                return fontSize - 1;
+        }
+        var height = font.heightAtSize(fontSize, { descender: false });
+        if (height > cellHeight)
+            return fontSize - 1;
+        fontSize += 1;
+    }
+    return fontSize;
+};
+var lastIndexOfWhitespace = function (line) {
+    for (var idx = line.length; idx > 0; idx--) {
+        if (/\s/.test(line[idx]))
+            return idx;
+    }
+    return undefined;
+};
+var splitOutLines = function (input, maxWidth, font, fontSize) {
+    var _a;
+    var lastWhitespaceIdx = input.length;
+    while (lastWhitespaceIdx > 0) {
+        var line = input.substring(0, lastWhitespaceIdx);
+        var encoded = font.encodeText(line);
+        var width = font.widthOfTextAtSize(line, fontSize);
+        if (width < maxWidth) {
+            var remainder = input.substring(lastWhitespaceIdx) || undefined;
+            return { line: line, encoded: encoded, width: width, remainder: remainder };
+        }
+        lastWhitespaceIdx = (_a = lastIndexOfWhitespace(line)) !== null && _a !== void 0 ? _a : 0;
+    }
+    // We were unable to split the input enough to get a chunk that would fit
+    // within the specified `maxWidth` so we'll just return everything
+    return {
+        line: input,
+        encoded: font.encodeText(input),
+        width: font.widthOfTextAtSize(input, fontSize),
+        remainder: undefined,
+    };
+};
+var layoutMultilineText = function (text, _a) {
+    var alignment = _a.alignment, fontSize = _a.fontSize, font = _a.font, bounds = _a.bounds;
+    var lines = lineSplit(cleanText(text));
+    if (fontSize === undefined || fontSize === 0) {
+        fontSize = computeFontSize(lines, font, bounds, true);
+    }
+    var height = font.heightAtSize(fontSize);
+    var lineHeight = height + height * 0.2;
+    var textLines = [];
+    var minX = bounds.x;
+    var minY = bounds.y;
+    var maxX = bounds.x + bounds.width;
+    var maxY = bounds.y + bounds.height;
+    var y = bounds.y + bounds.height;
+    for (var idx = 0, len = lines.length; idx < len; idx++) {
+        var prevRemainder = lines[idx];
+        while (prevRemainder !== undefined) {
+            var _b = splitOutLines(prevRemainder, bounds.width, font, fontSize), line = _b.line, encoded = _b.encoded, width = _b.width, remainder = _b.remainder;
+            // prettier-ignore
+            var x = (alignment === TextAlignment.Left ? bounds.x
+                : alignment === TextAlignment.Center ? bounds.x + (bounds.width / 2) - (width / 2)
+                    : alignment === TextAlignment.Right ? bounds.x + bounds.width - width
+                        : bounds.x);
+            y -= lineHeight;
+            if (x < minX)
+                minX = x;
+            if (y < minY)
+                minY = y;
+            if (x + width > maxX)
+                maxX = x + width;
+            if (y + height > maxY)
+                maxY = y + height;
+            textLines.push({ text: line, encoded: encoded, width: width, height: height, x: x, y: y });
+            // Only trim lines that we had to split ourselves. So we won't trim lines
+            // that the user provided themselves with whitespace.
+            prevRemainder = remainder === null || remainder === void 0 ? void 0 : remainder.trim();
+        }
+    }
+    return {
+        fontSize: fontSize,
+        lineHeight: lineHeight,
+        lines: textLines,
+        bounds: {
+            x: minX,
+            y: minY,
+            width: maxX - minX,
+            height: maxY - minY,
+        },
+    };
+};
+var layoutCombedText = function (text, _a) {
+    var fontSize = _a.fontSize, font = _a.font, bounds = _a.bounds, cellCount = _a.cellCount;
+    var line = mergeLines(cleanText(text));
+    if (line.length > cellCount) {
+        throw new CombedTextLayoutError(line.length, cellCount);
+    }
+    if (fontSize === undefined || fontSize === 0) {
+        fontSize = computeCombedFontSize(line, font, bounds, cellCount);
+    }
+    var cellWidth = bounds.width / cellCount;
+    var height = font.heightAtSize(fontSize, { descender: false });
+    var y = bounds.y + (bounds.height / 2 - height / 2);
+    var cells = [];
+    var minX = bounds.x;
+    var minY = bounds.y;
+    var maxX = bounds.x + bounds.width;
+    var maxY = bounds.y + bounds.height;
+    var cellOffset = 0;
+    var charOffset = 0;
+    while (cellOffset < cellCount) {
+        var _b = charAtIndex(line, charOffset), char = _b[0], charLength = _b[1];
+        var encoded = font.encodeText(char);
+        var width = font.widthOfTextAtSize(char, fontSize);
+        var cellCenter = bounds.x + (cellWidth * cellOffset + cellWidth / 2);
+        var x = cellCenter - width / 2;
+        if (x < minX)
+            minX = x;
+        if (y < minY)
+            minY = y;
+        if (x + width > maxX)
+            maxX = x + width;
+        if (y + height > maxY)
+            maxY = y + height;
+        cells.push({ text: line, encoded: encoded, width: width, height: height, x: x, y: y });
+        cellOffset += 1;
+        charOffset += charLength;
+    }
+    return {
+        fontSize: fontSize,
+        cells: cells,
+        bounds: {
+            x: minX,
+            y: minY,
+            width: maxX - minX,
+            height: maxY - minY,
+        },
+    };
+};
+var layoutSinglelineText = function (text, _a) {
+    var alignment = _a.alignment, fontSize = _a.fontSize, font = _a.font, bounds = _a.bounds;
+    var line = mergeLines(cleanText(text));
+    if (fontSize === undefined || fontSize === 0) {
+        fontSize = computeFontSize([line], font, bounds);
+    }
+    var encoded = font.encodeText(line);
+    var width = font.widthOfTextAtSize(line, fontSize);
+    var height = font.heightAtSize(fontSize, { descender: false });
+    // prettier-ignore
+    var x = (alignment === TextAlignment.Left ? bounds.x
+        : alignment === TextAlignment.Center ? bounds.x + (bounds.width / 2) - (width / 2)
+            : alignment === TextAlignment.Right ? bounds.x + bounds.width - width
+                : bounds.x);
+    var y = bounds.y + (bounds.height / 2 - height / 2);
+    return {
+        fontSize: fontSize,
+        line: { text: line, encoded: encoded, width: width, height: height, x: x, y: y },
+        bounds: { x: x, y: y, width: width, height: height },
+    };
+};
+
+export { layoutCombedText, layoutMultilineText, layoutSinglelineText };

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

@@ -0,0 +1,205 @@
+import { __assign } from '../../../tslib/tslib.es6.js';
+import pako from '../../../../_virtual/index8.js';
+import PDFHeader from './document/PDFHeader.js';
+import { UnexpectedObjectTypeError } from './errors.js';
+import PDFArray from './objects/PDFArray.js';
+import PDFBool from './objects/PDFBool.js';
+import PDFDict from './objects/PDFDict.js';
+import PDFName from './objects/PDFName.js';
+import PDFNull from './objects/PDFNull.js';
+import PDFNumber from './objects/PDFNumber.js';
+import PDFObject from './objects/PDFObject.js';
+import PDFRawStream from './objects/PDFRawStream.js';
+import PDFRef from './objects/PDFRef.js';
+import PDFOperator from './operators/PDFOperator.js';
+import Ops from './operators/PDFOperatorNames.js';
+import PDFContentStream from './structures/PDFContentStream.js';
+import { typedArrayFor } from '../utils/arrays.js';
+import '../utils/unicode.js';
+import '../utils/base64.js';
+import '../utils/objects.js';
+import '../utils/pdfDocEncoding.js';
+import '../utils/Cache.js';
+import { SimpleRNG } from '../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.forVersion(1, 7);
+        this.trailerInfo = {};
+        this.indirectObjects = new Map();
+        this.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.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);
+        var result = ref instanceof PDFRef ? this.indirectObjects.get(ref) : ref;
+        if (!result || (result === PDFNull && !preservePDFNull))
+            return undefined;
+        for (var idx = 0, len = types.length; idx < len; idx++) {
+            var type = types[idx];
+            if (type === PDFNull) {
+                if (result === PDFNull)
+                    return result;
+            }
+            else {
+                if (result instanceof type)
+                    return result;
+            }
+        }
+        throw new 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 ? 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) {
+                if (result === PDFNull)
+                    return result;
+            }
+            else {
+                if (result instanceof type)
+                    return result;
+            }
+        }
+        throw new 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) {
+            return literal;
+        }
+        else if (literal === null || literal === undefined) {
+            return PDFNull;
+        }
+        else if (typeof literal === 'string') {
+            return PDFName.of(literal);
+        }
+        else if (typeof literal === 'number') {
+            return PDFNumber.of(literal);
+        }
+        else if (typeof literal === 'boolean') {
+            return literal ? PDFBool.True : PDFBool.False;
+        }
+        else if (Array.isArray(literal)) {
+            var array = PDFArray.withContext(this);
+            for (var idx = 0, len = literal.length; idx < len; idx++) {
+                array.push(this.obj(literal[idx]));
+            }
+            return array;
+        }
+        else {
+            var dict = PDFDict.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.of(key), this.obj(value));
+            }
+            return dict;
+        }
+    };
+    PDFContext.prototype.stream = function (contents, dict) {
+        if (dict === void 0) { dict = {}; }
+        return PDFRawStream.of(this.obj(dict), typedArrayFor(contents));
+    };
+    PDFContext.prototype.flateStream = function (contents, dict) {
+        if (dict === void 0) { dict = {}; }
+        return this.stream(pako.deflate(typedArrayFor(contents)), __assign(__assign({}, dict), { Filter: 'FlateDecode' }));
+    };
+    PDFContext.prototype.contentStream = function (operators, dict) {
+        if (dict === void 0) { dict = {}; }
+        return PDFContentStream.of(this.obj(dict), operators);
+    };
+    PDFContext.prototype.formXObject = function (operators, dict) {
+        if (dict === void 0) { dict = {}; }
+        return this.contentStream(operators, __assign(__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.of(Ops.PushGraphicsState);
+        var stream = PDFContentStream.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.of(Ops.PopGraphicsState);
+        var stream = PDFContentStream.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;
+}());
+
+export { PDFContext as default };

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

@@ -0,0 +1,117 @@
+import PDFArray from './objects/PDFArray.js';
+import PDFDict from './objects/PDFDict.js';
+import PDFName from './objects/PDFName.js';
+import PDFRef from './objects/PDFRef.js';
+import PDFStream from './objects/PDFStream.js';
+import PDFPageLeaf from './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 ? _this.copyPDFPage(object)
+            : object instanceof PDFDict ? _this.copyPDFDict(object)
+                : object instanceof PDFArray ? _this.copyPDFArray(object)
+                    : object instanceof PDFStream ? _this.copyPDFStream(object)
+                        : object instanceof PDFRef ? _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.InheritableEntries;
+            for (var idx = 0, len = InheritableEntries.length; idx < len; idx++) {
+                var key = PDFName.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.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;
+}());
+
+export { PDFObjectCopier as default };

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

@@ -0,0 +1,95 @@
+import { __extends } from '../../../../tslib/tslib.es6.js';
+import PDFString from '../objects/PDFString.js';
+import PDFHexString from '../objects/PDFHexString.js';
+import PDFArray from '../objects/PDFArray.js';
+import PDFName from '../objects/PDFName.js';
+import PDFAcroTerminal from './PDFAcroTerminal.js';
+import { IndexOutOfBoundsError } from '../errors.js';
+
+var PDFAcroButton = /** @class */ (function (_super) {
+    __extends(PDFAcroButton, _super);
+    function PDFAcroButton() {
+        return _super !== null && _super.apply(this, arguments) || this;
+    }
+    PDFAcroButton.prototype.Opt = function () {
+        return this.dict.lookupMaybe(PDFName.of('Opt'), PDFString, PDFHexString, PDFArray);
+    };
+    PDFAcroButton.prototype.setOpt = function (opt) {
+        this.dict.set(PDFName.of('Opt'), this.dict.context.obj(opt));
+    };
+    PDFAcroButton.prototype.getExportValues = function () {
+        var opt = this.Opt();
+        if (!opt)
+            return undefined;
+        if (opt instanceof PDFString || opt instanceof PDFHexString) {
+            return [opt];
+        }
+        var values = [];
+        for (var idx = 0, len = opt.size(); idx < len; idx++) {
+            var value = opt.lookup(idx);
+            if (value instanceof PDFString || value instanceof PDFHexString) {
+                values.push(value);
+            }
+        }
+        return values;
+    };
+    PDFAcroButton.prototype.removeExportValue = function (idx) {
+        var opt = this.Opt();
+        if (!opt)
+            return;
+        if (opt instanceof PDFString || opt instanceof PDFHexString) {
+            if (idx !== 0)
+                throw new IndexOutOfBoundsError(idx, 0, 0);
+            this.setOpt([]);
+        }
+        else {
+            if (idx < 0 || idx > opt.size()) {
+                throw new 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.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.of(String(optIdx));
+        this.addWidget(widget);
+        return apStateValue;
+    };
+    return PDFAcroButton;
+}(PDFAcroTerminal));
+
+export { PDFAcroButton as default };