art-bd-ui 1.0.21 → 1.0.23

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

@@ -0,0 +1,49 @@
+import { __extends } from '../../../../tslib/tslib.es6.js';
+import PDFName from '../objects/PDFName.js';
+import PDFAcroButton from './PDFAcroButton.js';
+import { InvalidAcroFieldValueError } from '../errors.js';
+
+var PDFAcroCheckBox = /** @class */ (function (_super) {
+    __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.of('Yes');
+        if (value !== onValue && value !== PDFName.of('Off')) {
+            throw new InvalidAcroFieldValueError();
+        }
+        this.dict.set(PDFName.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.of('Off');
+            widget.setAppearanceState(state);
+        }
+    };
+    PDFAcroCheckBox.prototype.getValue = function () {
+        var v = this.V();
+        if (v instanceof PDFName)
+            return v;
+        return PDFName.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));
+
+export { PDFAcroCheckBox as default };

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

@@ -0,0 +1,126 @@
+import { __extends } from '../../../../tslib/tslib.es6.js';
+import PDFAcroTerminal from './PDFAcroTerminal.js';
+import PDFHexString from '../objects/PDFHexString.js';
+import PDFString from '../objects/PDFString.js';
+import PDFArray from '../objects/PDFArray.js';
+import PDFName from '../objects/PDFName.js';
+import { AcroChoiceFlags } from './flags.js';
+import { InvalidAcroFieldValueError, MultiSelectValueError } from '../errors.js';
+
+var PDFAcroChoice = /** @class */ (function (_super) {
+    __extends(PDFAcroChoice, _super);
+    function PDFAcroChoice() {
+        return _super !== null && _super.apply(this, arguments) || this;
+    }
+    PDFAcroChoice.prototype.setValues = function (values) {
+        if (this.hasFlag(AcroChoiceFlags.Combo) &&
+            !this.hasFlag(AcroChoiceFlags.Edit) &&
+            !this.valuesAreValid(values)) {
+            throw new InvalidAcroFieldValueError();
+        }
+        if (values.length === 0) {
+            this.dict.delete(PDFName.of('V'));
+        }
+        if (values.length === 1) {
+            this.dict.set(PDFName.of('V'), values[0]);
+        }
+        if (values.length > 1) {
+            if (!this.hasFlag(AcroChoiceFlags.MultiSelect)) {
+                throw new MultiSelectValueError();
+            }
+            this.dict.set(PDFName.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.of('I'), this.dict.context.obj(indices.sort()));
+        }
+        else {
+            this.dict.delete(PDFName.of('I'));
+        }
+    };
+    PDFAcroChoice.prototype.getValues = function () {
+        var v = this.V();
+        if (v instanceof PDFString || v instanceof PDFHexString)
+            return [v];
+        if (v instanceof PDFArray) {
+            var values = [];
+            for (var idx = 0, len = v.size(); idx < len; idx++) {
+                var value = v.lookup(idx);
+                if (value instanceof PDFString || value instanceof PDFHexString) {
+                    values.push(value);
+                }
+            }
+            return values;
+        }
+        return [];
+    };
+    PDFAcroChoice.prototype.Opt = function () {
+        return this.dict.lookupMaybe(PDFName.of('Opt'), PDFString, PDFHexString, PDFArray);
+    };
+    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.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 || Opt instanceof PDFHexString) {
+            return [{ value: Opt, display: Opt }];
+        }
+        if (Opt instanceof PDFArray) {
+            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 || item instanceof PDFHexString) {
+                    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) {
+                    if (item.size() > 0) {
+                        var first = item.lookup(0, PDFString, PDFHexString);
+                        var second = item.lookupMaybe(1, PDFString, PDFHexString);
+                        res.push({ value: first, display: second || first });
+                    }
+                }
+            }
+            return res;
+        }
+        return [];
+    };
+    return PDFAcroChoice;
+}(PDFAcroTerminal));
+
+export { PDFAcroChoice as default };

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

@@ -0,0 +1,25 @@
+import { __extends } from '../../../../tslib/tslib.es6.js';
+import PDFAcroChoice from './PDFAcroChoice.js';
+import { AcroChoiceFlags } from './flags.js';
+
+var PDFAcroComboBox = /** @class */ (function (_super) {
+    __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: AcroChoiceFlags.Combo,
+            Kids: [],
+        });
+        var ref = context.register(dict);
+        return new PDFAcroComboBox(dict, ref);
+    };
+    return PDFAcroComboBox;
+}(PDFAcroChoice));
+
+export { PDFAcroComboBox as default };

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

@@ -0,0 +1,152 @@
+import PDFDict from '../objects/PDFDict.js';
+import PDFString from '../objects/PDFString.js';
+import PDFHexString from '../objects/PDFHexString.js';
+import PDFName from '../objects/PDFName.js';
+import PDFNumber from '../objects/PDFNumber.js';
+import PDFArray from '../objects/PDFArray.js';
+import PDFRef from '../objects/PDFRef.js';
+import '../../utils/base64.js';
+import { findLastMatch } from '../../utils/strings.js';
+import '../../utils/unicode.js';
+import '../../utils/objects.js';
+import '../../utils/pdfDocEncoding.js';
+import '../../utils/Cache.js';
+import { MissingDAEntryError, MissingTfOperatorError } from '../errors.js';
+
+// Examples:
+//   `/Helv 12 Tf` -> ['Helv', '12']
+//   `/HeBo 8.00 Tf` -> ['HeBo', '8.00']
+//   `/HeBo Tf` -> ['HeBo', undefined]
+var tfRegex = /\/([^\0\t\n\f\r\ ]+)[\0\t\n\f\r\ ]*(\d*\.\d+|\d+)?[\0\t\n\f\r\ ]+Tf/;
+var PDFAcroField = /** @class */ (function () {
+    function PDFAcroField(dict, ref) {
+        this.dict = dict;
+        this.ref = ref;
+    }
+    PDFAcroField.prototype.T = function () {
+        return this.dict.lookupMaybe(PDFName.of('T'), PDFString, PDFHexString);
+    };
+    PDFAcroField.prototype.Ff = function () {
+        var numberOrRef = this.getInheritableAttribute(PDFName.of('Ff'));
+        return this.dict.context.lookupMaybe(numberOrRef, PDFNumber);
+    };
+    PDFAcroField.prototype.V = function () {
+        var valueOrRef = this.getInheritableAttribute(PDFName.of('V'));
+        return this.dict.context.lookup(valueOrRef);
+    };
+    PDFAcroField.prototype.Kids = function () {
+        return this.dict.lookupMaybe(PDFName.of('Kids'), PDFArray);
+    };
+    // Parent(): PDFDict | undefined {
+    //   return this.dict.lookupMaybe(PDFName.of('Parent'), PDFDict);
+    // }
+    PDFAcroField.prototype.DA = function () {
+        var da = this.dict.lookup(PDFName.of('DA'));
+        if (da instanceof PDFString || da instanceof PDFHexString)
+            return da;
+        return undefined;
+    };
+    PDFAcroField.prototype.setKids = function (kids) {
+        this.dict.set(PDFName.of('Kids'), this.dict.context.obj(kids));
+    };
+    PDFAcroField.prototype.getParent = function () {
+        // const parent = this.Parent();
+        // if (!parent) return undefined;
+        // return new PDFAcroField(parent);
+        var parentRef = this.dict.get(PDFName.of('Parent'));
+        if (parentRef instanceof PDFRef) {
+            var parent_1 = this.dict.lookup(PDFName.of('Parent'), PDFDict);
+            return new PDFAcroField(parent_1, parentRef);
+        }
+        return undefined;
+    };
+    PDFAcroField.prototype.setParent = function (parent) {
+        if (!parent)
+            this.dict.delete(PDFName.of('Parent'));
+        else
+            this.dict.set(PDFName.of('Parent'), parent);
+    };
+    PDFAcroField.prototype.getFullyQualifiedName = function () {
+        var parent = this.getParent();
+        if (!parent)
+            return this.getPartialName();
+        return parent.getFullyQualifiedName() + "." + this.getPartialName();
+    };
+    PDFAcroField.prototype.getPartialName = function () {
+        var _a;
+        return (_a = this.T()) === null || _a === void 0 ? void 0 : _a.decodeText();
+    };
+    PDFAcroField.prototype.setPartialName = function (partialName) {
+        if (!partialName)
+            this.dict.delete(PDFName.of('T'));
+        else
+            this.dict.set(PDFName.of('T'), PDFHexString.fromText(partialName));
+    };
+    PDFAcroField.prototype.setDefaultAppearance = function (appearance) {
+        this.dict.set(PDFName.of('DA'), PDFString.of(appearance));
+    };
+    PDFAcroField.prototype.getDefaultAppearance = function () {
+        var DA = this.DA();
+        if (DA instanceof PDFHexString) {
+            return DA.decodeText();
+        }
+        return DA === null || DA === void 0 ? void 0 : DA.asString();
+    };
+    PDFAcroField.prototype.setFontSize = function (fontSize) {
+        var _a;
+        var name = (_a = this.getFullyQualifiedName()) !== null && _a !== void 0 ? _a : '';
+        var da = this.getDefaultAppearance();
+        if (!da)
+            throw new MissingDAEntryError(name);
+        var daMatch = findLastMatch(da, tfRegex);
+        if (!daMatch.match)
+            throw new MissingTfOperatorError(name);
+        var daStart = da.slice(0, daMatch.pos - daMatch.match[0].length);
+        var daEnd = daMatch.pos <= da.length ? da.slice(daMatch.pos) : '';
+        var fontName = daMatch.match[1];
+        var modifiedDa = daStart + " /" + fontName + " " + fontSize + " Tf " + daEnd;
+        this.setDefaultAppearance(modifiedDa);
+    };
+    PDFAcroField.prototype.getFlags = function () {
+        var _a, _b;
+        return (_b = (_a = this.Ff()) === null || _a === void 0 ? void 0 : _a.asNumber()) !== null && _b !== void 0 ? _b : 0;
+    };
+    PDFAcroField.prototype.setFlags = function (flags) {
+        this.dict.set(PDFName.of('Ff'), PDFNumber.of(flags));
+    };
+    PDFAcroField.prototype.hasFlag = function (flag) {
+        var flags = this.getFlags();
+        return (flags & flag) !== 0;
+    };
+    PDFAcroField.prototype.setFlag = function (flag) {
+        var flags = this.getFlags();
+        this.setFlags(flags | flag);
+    };
+    PDFAcroField.prototype.clearFlag = function (flag) {
+        var flags = this.getFlags();
+        this.setFlags(flags & ~flag);
+    };
+    PDFAcroField.prototype.setFlagTo = function (flag, enable) {
+        if (enable)
+            this.setFlag(flag);
+        else
+            this.clearFlag(flag);
+    };
+    PDFAcroField.prototype.getInheritableAttribute = function (name) {
+        var attribute;
+        this.ascend(function (node) {
+            if (!attribute)
+                attribute = node.dict.get(name);
+        });
+        return attribute;
+    };
+    PDFAcroField.prototype.ascend = function (visitor) {
+        visitor(this);
+        var parent = this.getParent();
+        if (parent)
+            parent.ascend(visitor);
+    };
+    return PDFAcroField;
+}());
+
+export { PDFAcroField as default };

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

@@ -0,0 +1,76 @@
+import PDFDict from '../objects/PDFDict.js';
+import PDFArray from '../objects/PDFArray.js';
+import PDFName from '../objects/PDFName.js';
+import PDFAcroNonTerminal from './PDFAcroNonTerminal.js';
+import { createPDFAcroField, createPDFAcroFields } from './utils.js';
+
+var PDFAcroForm = /** @class */ (function () {
+    function PDFAcroForm(dict) {
+        this.dict = dict;
+    }
+    PDFAcroForm.prototype.Fields = function () {
+        var fields = this.dict.lookup(PDFName.of('Fields'));
+        if (fields instanceof PDFArray)
+            return fields;
+        return undefined;
+    };
+    PDFAcroForm.prototype.getFields = function () {
+        var Fields = this.normalizedEntries().Fields;
+        var fields = new Array(Fields.size());
+        for (var idx = 0, len = Fields.size(); idx < len; idx++) {
+            var ref = Fields.get(idx);
+            var dict = Fields.lookup(idx, PDFDict);
+            fields[idx] = [createPDFAcroField(dict, ref), ref];
+        }
+        return fields;
+    };
+    PDFAcroForm.prototype.getAllFields = function () {
+        var allFields = [];
+        var pushFields = function (fields) {
+            if (!fields)
+                return;
+            for (var idx = 0, len = fields.length; idx < len; idx++) {
+                var field = fields[idx];
+                allFields.push(field);
+                var fieldModel = field[0];
+                if (fieldModel instanceof PDFAcroNonTerminal) {
+                    pushFields(createPDFAcroFields(fieldModel.Kids()));
+                }
+            }
+        };
+        pushFields(this.getFields());
+        return allFields;
+    };
+    PDFAcroForm.prototype.addField = function (field) {
+        var Fields = this.normalizedEntries().Fields;
+        Fields === null || Fields === void 0 ? void 0 : Fields.push(field);
+    };
+    PDFAcroForm.prototype.removeField = function (field) {
+        var parent = field.getParent();
+        var fields = parent === undefined ? this.normalizedEntries().Fields : parent.Kids();
+        var index = fields === null || fields === void 0 ? void 0 : fields.indexOf(field.ref);
+        if (fields === undefined || index === undefined) {
+            throw new Error("Tried to remove inexistent field " + field.getFullyQualifiedName());
+        }
+        fields.remove(index);
+        if (parent !== undefined && fields.size() === 0) {
+            this.removeField(parent);
+        }
+    };
+    PDFAcroForm.prototype.normalizedEntries = function () {
+        var Fields = this.Fields();
+        if (!Fields) {
+            Fields = this.dict.context.obj([]);
+            this.dict.set(PDFName.of('Fields'), Fields);
+        }
+        return { Fields: Fields };
+    };
+    PDFAcroForm.fromDict = function (dict) { return new PDFAcroForm(dict); };
+    PDFAcroForm.create = function (context) {
+        var dict = context.obj({ Fields: [] });
+        return new PDFAcroForm(dict);
+    };
+    return PDFAcroForm;
+}());
+
+export { PDFAcroForm as default };

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

@@ -0,0 +1,23 @@
+import { __extends } from '../../../../tslib/tslib.es6.js';
+import PDFAcroChoice from './PDFAcroChoice.js';
+
+var PDFAcroListBox = /** @class */ (function (_super) {
+    __extends(PDFAcroListBox, _super);
+    function PDFAcroListBox() {
+        return _super !== null && _super.apply(this, arguments) || this;
+    }
+    PDFAcroListBox.fromDict = function (dict, ref) {
+        return new PDFAcroListBox(dict, ref);
+    };
+    PDFAcroListBox.create = function (context) {
+        var dict = context.obj({
+            FT: 'Ch',
+            Kids: [],
+        });
+        var ref = context.register(dict);
+        return new PDFAcroListBox(dict, ref);
+    };
+    return PDFAcroListBox;
+}(PDFAcroChoice));
+
+export { PDFAcroListBox as default };

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

@@ -0,0 +1,33 @@
+import { __extends } from '../../../../tslib/tslib.es6.js';
+import PDFName from '../objects/PDFName.js';
+import PDFAcroField from './PDFAcroField.js';
+
+var PDFAcroNonTerminal = /** @class */ (function (_super) {
+    __extends(PDFAcroNonTerminal, _super);
+    function PDFAcroNonTerminal() {
+        return _super !== null && _super.apply(this, arguments) || this;
+    }
+    PDFAcroNonTerminal.prototype.addField = function (field) {
+        var Kids = this.normalizedEntries().Kids;
+        Kids === null || Kids === void 0 ? void 0 : Kids.push(field);
+    };
+    PDFAcroNonTerminal.prototype.normalizedEntries = function () {
+        var Kids = this.Kids();
+        if (!Kids) {
+            Kids = this.dict.context.obj([]);
+            this.dict.set(PDFName.of('Kids'), Kids);
+        }
+        return { Kids: Kids };
+    };
+    PDFAcroNonTerminal.fromDict = function (dict, ref) {
+        return new PDFAcroNonTerminal(dict, ref);
+    };
+    PDFAcroNonTerminal.create = function (context) {
+        var dict = context.obj({});
+        var ref = context.register(dict);
+        return new PDFAcroNonTerminal(dict, ref);
+    };
+    return PDFAcroNonTerminal;
+}(PDFAcroField));
+
+export { PDFAcroNonTerminal as default };

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

@@ -0,0 +1,25 @@
+import { __extends } from '../../../../tslib/tslib.es6.js';
+import PDFAcroButton from './PDFAcroButton.js';
+import { AcroButtonFlags } from './flags.js';
+
+var PDFAcroPushButton = /** @class */ (function (_super) {
+    __extends(PDFAcroPushButton, _super);
+    function PDFAcroPushButton() {
+        return _super !== null && _super.apply(this, arguments) || this;
+    }
+    PDFAcroPushButton.fromDict = function (dict, ref) {
+        return new PDFAcroPushButton(dict, ref);
+    };
+    PDFAcroPushButton.create = function (context) {
+        var dict = context.obj({
+            FT: 'Btn',
+            Ff: AcroButtonFlags.PushButton,
+            Kids: [],
+        });
+        var ref = context.register(dict);
+        return new PDFAcroPushButton(dict, ref);
+    };
+    return PDFAcroPushButton;
+}(PDFAcroButton));
+
+export { PDFAcroPushButton as default };

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

@@ -0,0 +1,56 @@
+import { __extends } from '../../../../tslib/tslib.es6.js';
+import PDFName from '../objects/PDFName.js';
+import PDFAcroButton from './PDFAcroButton.js';
+import { AcroButtonFlags } from './flags.js';
+import { InvalidAcroFieldValueError } from '../errors.js';
+
+var PDFAcroRadioButton = /** @class */ (function (_super) {
+    __extends(PDFAcroRadioButton, _super);
+    function PDFAcroRadioButton() {
+        return _super !== null && _super.apply(this, arguments) || this;
+    }
+    PDFAcroRadioButton.prototype.setValue = function (value) {
+        var onValues = this.getOnValues();
+        if (!onValues.includes(value) && value !== PDFName.of('Off')) {
+            throw new InvalidAcroFieldValueError();
+        }
+        this.dict.set(PDFName.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.of('Off');
+            widget.setAppearanceState(state);
+        }
+    };
+    PDFAcroRadioButton.prototype.getValue = function () {
+        var v = this.V();
+        if (v instanceof PDFName)
+            return v;
+        return PDFName.of('Off');
+    };
+    PDFAcroRadioButton.prototype.getOnValues = function () {
+        var widgets = this.getWidgets();
+        var onValues = [];
+        for (var idx = 0, len = widgets.length; idx < len; idx++) {
+            var onValue = widgets[idx].getOnValue();
+            if (onValue)
+                onValues.push(onValue);
+        }
+        return onValues;
+    };
+    PDFAcroRadioButton.fromDict = function (dict, ref) {
+        return new PDFAcroRadioButton(dict, ref);
+    };
+    PDFAcroRadioButton.create = function (context) {
+        var dict = context.obj({
+            FT: 'Btn',
+            Ff: AcroButtonFlags.Radio,
+            Kids: [],
+        });
+        var ref = context.register(dict);
+        return new PDFAcroRadioButton(dict, ref);
+    };
+    return PDFAcroRadioButton;
+}(PDFAcroButton));
+
+export { PDFAcroRadioButton as default };

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

@@ -0,0 +1,15 @@
+import { __extends } from '../../../../tslib/tslib.es6.js';
+import PDFAcroTerminal from './PDFAcroTerminal.js';
+
+var PDFAcroSignature = /** @class */ (function (_super) {
+    __extends(PDFAcroSignature, _super);
+    function PDFAcroSignature() {
+        return _super !== null && _super.apply(this, arguments) || this;
+    }
+    PDFAcroSignature.fromDict = function (dict, ref) {
+        return new PDFAcroSignature(dict, ref);
+    };
+    return PDFAcroSignature;
+}(PDFAcroTerminal));
+
+export { PDFAcroSignature as default };

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

@@ -0,0 +1,69 @@
+import { __extends } from '../../../../tslib/tslib.es6.js';
+import PDFDict from '../objects/PDFDict.js';
+import PDFName from '../objects/PDFName.js';
+import PDFAcroField from './PDFAcroField.js';
+import PDFWidgetAnnotation from '../annotation/PDFWidgetAnnotation.js';
+import { IndexOutOfBoundsError } from '../errors.js';
+
+var PDFAcroTerminal = /** @class */ (function (_super) {
+    __extends(PDFAcroTerminal, _super);
+    function PDFAcroTerminal() {
+        return _super !== null && _super.apply(this, arguments) || this;
+    }
+    PDFAcroTerminal.prototype.FT = function () {
+        var nameOrRef = this.getInheritableAttribute(PDFName.of('FT'));
+        return this.dict.context.lookup(nameOrRef, PDFName);
+    };
+    PDFAcroTerminal.prototype.getWidgets = function () {
+        var kidDicts = this.Kids();
+        // This field is itself a widget
+        if (!kidDicts)
+            return [PDFWidgetAnnotation.fromDict(this.dict)];
+        // This field's kids are its widgets
+        var widgets = new Array(kidDicts.size());
+        for (var idx = 0, len = kidDicts.size(); idx < len; idx++) {
+            var dict = kidDicts.lookup(idx, PDFDict);
+            widgets[idx] = PDFWidgetAnnotation.fromDict(dict);
+        }
+        return widgets;
+    };
+    PDFAcroTerminal.prototype.addWidget = function (ref) {
+        var Kids = this.normalizedEntries().Kids;
+        Kids.push(ref);
+    };
+    PDFAcroTerminal.prototype.removeWidget = function (idx) {
+        var kidDicts = this.Kids();
+        if (!kidDicts) {
+            // This field is itself a widget
+            if (idx !== 0)
+                throw new IndexOutOfBoundsError(idx, 0, 0);
+            this.setKids([]);
+        }
+        else {
+            // This field's kids are its widgets
+            if (idx < 0 || idx > kidDicts.size()) {
+                throw new IndexOutOfBoundsError(idx, 0, kidDicts.size());
+            }
+            kidDicts.remove(idx);
+        }
+    };
+    PDFAcroTerminal.prototype.normalizedEntries = function () {
+        var Kids = this.Kids();
+        // If this field is itself a widget (because it was only rendered once in
+        // the document, so the field and widget properties were merged) then we
+        // add itself to the `Kids` array. The alternative would be to try
+        // splitting apart the widget properties and creating a separate object
+        // for them.
+        if (!Kids) {
+            Kids = this.dict.context.obj([this.ref]);
+            this.dict.set(PDFName.of('Kids'), Kids);
+        }
+        return { Kids: Kids };
+    };
+    PDFAcroTerminal.fromDict = function (dict, ref) {
+        return new PDFAcroTerminal(dict, ref);
+    };
+    return PDFAcroTerminal;
+}(PDFAcroField));
+
+export { PDFAcroTerminal as default };