art-bd-ui 1.0.21 → 1.0.23

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

@@ -0,0 +1,156 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+var PDFDict = require('../objects/PDFDict.js');
+var PDFString = require('../objects/PDFString.js');
+var PDFHexString = require('../objects/PDFHexString.js');
+var PDFName = require('../objects/PDFName.js');
+var PDFNumber = require('../objects/PDFNumber.js');
+var PDFArray = require('../objects/PDFArray.js');
+var PDFRef = require('../objects/PDFRef.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 errors = require('../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.default.of('T'), PDFString.default, PDFHexString.default);
+    };
+    PDFAcroField.prototype.Ff = function () {
+        var numberOrRef = this.getInheritableAttribute(PDFName.default.of('Ff'));
+        return this.dict.context.lookupMaybe(numberOrRef, PDFNumber.default);
+    };
+    PDFAcroField.prototype.V = function () {
+        var valueOrRef = this.getInheritableAttribute(PDFName.default.of('V'));
+        return this.dict.context.lookup(valueOrRef);
+    };
+    PDFAcroField.prototype.Kids = function () {
+        return this.dict.lookupMaybe(PDFName.default.of('Kids'), PDFArray.default);
+    };
+    // Parent(): PDFDict | undefined {
+    //   return this.dict.lookupMaybe(PDFName.of('Parent'), PDFDict);
+    // }
+    PDFAcroField.prototype.DA = function () {
+        var da = this.dict.lookup(PDFName.default.of('DA'));
+        if (da instanceof PDFString.default || da instanceof PDFHexString.default)
+            return da;
+        return undefined;
+    };
+    PDFAcroField.prototype.setKids = function (kids) {
+        this.dict.set(PDFName.default.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.default.of('Parent'));
+        if (parentRef instanceof PDFRef.default) {
+            var parent_1 = this.dict.lookup(PDFName.default.of('Parent'), PDFDict.default);
+            return new PDFAcroField(parent_1, parentRef);
+        }
+        return undefined;
+    };
+    PDFAcroField.prototype.setParent = function (parent) {
+        if (!parent)
+            this.dict.delete(PDFName.default.of('Parent'));
+        else
+            this.dict.set(PDFName.default.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.default.of('T'));
+        else
+            this.dict.set(PDFName.default.of('T'), PDFHexString.default.fromText(partialName));
+    };
+    PDFAcroField.prototype.setDefaultAppearance = function (appearance) {
+        this.dict.set(PDFName.default.of('DA'), PDFString.default.of(appearance));
+    };
+    PDFAcroField.prototype.getDefaultAppearance = function () {
+        var DA = this.DA();
+        if (DA instanceof PDFHexString.default) {
+            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 errors.MissingDAEntryError(name);
+        var daMatch = strings.findLastMatch(da, tfRegex);
+        if (!daMatch.match)
+            throw new errors.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.default.of('Ff'), PDFNumber.default.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;
+}());
+
+exports.default = PDFAcroField;

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

@@ -0,0 +1,80 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+var PDFDict = require('../objects/PDFDict.js');
+var PDFArray = require('../objects/PDFArray.js');
+var PDFName = require('../objects/PDFName.js');
+var PDFAcroNonTerminal = require('./PDFAcroNonTerminal.js');
+var utils = require('./utils.js');
+
+var PDFAcroForm = /** @class */ (function () {
+    function PDFAcroForm(dict) {
+        this.dict = dict;
+    }
+    PDFAcroForm.prototype.Fields = function () {
+        var fields = this.dict.lookup(PDFName.default.of('Fields'));
+        if (fields instanceof PDFArray.default)
+            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.default);
+            fields[idx] = [utils.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.default) {
+                    pushFields(utils.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.default.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;
+}());
+
+exports.default = PDFAcroForm;

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

@@ -0,0 +1,27 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+var tslib_es6 = require('../../../../tslib/tslib.es6.js');
+var PDFAcroChoice = require('./PDFAcroChoice.js');
+
+var PDFAcroListBox = /** @class */ (function (_super) {
+    tslib_es6.__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.default));
+
+exports.default = PDFAcroListBox;

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

@@ -0,0 +1,37 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+var tslib_es6 = require('../../../../tslib/tslib.es6.js');
+var PDFName = require('../objects/PDFName.js');
+var PDFAcroField = require('./PDFAcroField.js');
+
+var PDFAcroNonTerminal = /** @class */ (function (_super) {
+    tslib_es6.__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.default.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.default));
+
+exports.default = PDFAcroNonTerminal;

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

@@ -0,0 +1,29 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+var tslib_es6 = require('../../../../tslib/tslib.es6.js');
+var PDFAcroButton = require('./PDFAcroButton.js');
+var flags = require('./flags.js');
+
+var PDFAcroPushButton = /** @class */ (function (_super) {
+    tslib_es6.__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: flags.AcroButtonFlags.PushButton,
+            Kids: [],
+        });
+        var ref = context.register(dict);
+        return new PDFAcroPushButton(dict, ref);
+    };
+    return PDFAcroPushButton;
+}(PDFAcroButton.default));
+
+exports.default = PDFAcroPushButton;

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

@@ -0,0 +1,60 @@
+'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 flags = require('./flags.js');
+var errors = require('../errors.js');
+
+var PDFAcroRadioButton = /** @class */ (function (_super) {
+    tslib_es6.__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.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);
+        }
+    };
+    PDFAcroRadioButton.prototype.getValue = function () {
+        var v = this.V();
+        if (v instanceof PDFName.default)
+            return v;
+        return PDFName.default.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: flags.AcroButtonFlags.Radio,
+            Kids: [],
+        });
+        var ref = context.register(dict);
+        return new PDFAcroRadioButton(dict, ref);
+    };
+    return PDFAcroRadioButton;
+}(PDFAcroButton.default));
+
+exports.default = PDFAcroRadioButton;

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

@@ -0,0 +1,19 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+var tslib_es6 = require('../../../../tslib/tslib.es6.js');
+var PDFAcroTerminal = require('./PDFAcroTerminal.js');
+
+var PDFAcroSignature = /** @class */ (function (_super) {
+    tslib_es6.__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.default));
+
+exports.default = PDFAcroSignature;

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

@@ -0,0 +1,73 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+var tslib_es6 = require('../../../../tslib/tslib.es6.js');
+var PDFDict = require('../objects/PDFDict.js');
+var PDFName = require('../objects/PDFName.js');
+var PDFAcroField = require('./PDFAcroField.js');
+var PDFWidgetAnnotation = require('../annotation/PDFWidgetAnnotation.js');
+var errors = require('../errors.js');
+
+var PDFAcroTerminal = /** @class */ (function (_super) {
+    tslib_es6.__extends(PDFAcroTerminal, _super);
+    function PDFAcroTerminal() {
+        return _super !== null && _super.apply(this, arguments) || this;
+    }
+    PDFAcroTerminal.prototype.FT = function () {
+        var nameOrRef = this.getInheritableAttribute(PDFName.default.of('FT'));
+        return this.dict.context.lookup(nameOrRef, PDFName.default);
+    };
+    PDFAcroTerminal.prototype.getWidgets = function () {
+        var kidDicts = this.Kids();
+        // This field is itself a widget
+        if (!kidDicts)
+            return [PDFWidgetAnnotation.default.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.default);
+            widgets[idx] = PDFWidgetAnnotation.default.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 errors.IndexOutOfBoundsError(idx, 0, 0);
+            this.setKids([]);
+        }
+        else {
+            // This field's kids are its widgets
+            if (idx < 0 || idx > kidDicts.size()) {
+                throw new errors.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.default.of('Kids'), Kids);
+        }
+        return { Kids: Kids };
+    };
+    PDFAcroTerminal.fromDict = function (dict, ref) {
+        return new PDFAcroTerminal(dict, ref);
+    };
+    return PDFAcroTerminal;
+}(PDFAcroField.default));
+
+exports.default = PDFAcroTerminal;

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

@@ -0,0 +1,76 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+var tslib_es6 = require('../../../../tslib/tslib.es6.js');
+var PDFNumber = require('../objects/PDFNumber.js');
+var PDFString = require('../objects/PDFString.js');
+var PDFHexString = require('../objects/PDFHexString.js');
+var PDFName = require('../objects/PDFName.js');
+var PDFAcroTerminal = require('./PDFAcroTerminal.js');
+
+var PDFAcroText = /** @class */ (function (_super) {
+    tslib_es6.__extends(PDFAcroText, _super);
+    function PDFAcroText() {
+        return _super !== null && _super.apply(this, arguments) || this;
+    }
+    PDFAcroText.prototype.MaxLen = function () {
+        var maxLen = this.dict.lookup(PDFName.default.of('MaxLen'));
+        if (maxLen instanceof PDFNumber.default)
+            return maxLen;
+        return undefined;
+    };
+    PDFAcroText.prototype.Q = function () {
+        var q = this.dict.lookup(PDFName.default.of('Q'));
+        if (q instanceof PDFNumber.default)
+            return q;
+        return undefined;
+    };
+    PDFAcroText.prototype.setMaxLength = function (maxLength) {
+        this.dict.set(PDFName.default.of('MaxLen'), PDFNumber.default.of(maxLength));
+    };
+    PDFAcroText.prototype.removeMaxLength = function () {
+        this.dict.delete(PDFName.default.of('MaxLen'));
+    };
+    PDFAcroText.prototype.getMaxLength = function () {
+        var _a;
+        return (_a = this.MaxLen()) === null || _a === void 0 ? void 0 : _a.asNumber();
+    };
+    PDFAcroText.prototype.setQuadding = function (quadding) {
+        this.dict.set(PDFName.default.of('Q'), PDFNumber.default.of(quadding));
+    };
+    PDFAcroText.prototype.getQuadding = function () {
+        var _a;
+        return (_a = this.Q()) === null || _a === void 0 ? void 0 : _a.asNumber();
+    };
+    PDFAcroText.prototype.setValue = function (value) {
+        this.dict.set(PDFName.default.of('V'), value);
+        // const widgets = this.getWidgets();
+        // for (let idx = 0, len = widgets.length; idx < len; idx++) {
+        //   const widget = widgets[idx];
+        //   const state = widget.getOnValue() === value ? value : PDFName.of('Off');
+        //   widget.setAppearanceState(state);
+        // }
+    };
+    PDFAcroText.prototype.removeValue = function () {
+        this.dict.delete(PDFName.default.of('V'));
+    };
+    PDFAcroText.prototype.getValue = function () {
+        var v = this.V();
+        if (v instanceof PDFString.default || v instanceof PDFHexString.default)
+            return v;
+        return undefined;
+    };
+    PDFAcroText.fromDict = function (dict, ref) { return new PDFAcroText(dict, ref); };
+    PDFAcroText.create = function (context) {
+        var dict = context.obj({
+            FT: 'Tx',
+            Kids: [],
+        });
+        var ref = context.register(dict);
+        return new PDFAcroText(dict, ref);
+    };
+    return PDFAcroText;
+}(PDFAcroTerminal.default));
+
+exports.default = PDFAcroText;