art-bd-ui 1.0.21 → 1.0.23

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

@@ -0,0 +1,148 @@
+'use strict';
+
+var flag = function (bitIndex) { return 1 << bitIndex; };
+/** From PDF spec table 221 */
+exports.AcroFieldFlags = void 0;
+(function (AcroFieldFlags) {
+    /**
+     * If set, the user may not change the value of the field. Any associated
+     * widget annotations will not interact with the user; that is, they will not
+     * respond to mouse clicks or change their appearance in response to mouse
+     * motions. This flag is useful for fields whose values are computed or
+     * imported from a database.
+     */
+    AcroFieldFlags[AcroFieldFlags["ReadOnly"] = flag(1 - 1)] = "ReadOnly";
+    /**
+     * If set, the field shall have a value at the time it is exported by a
+     * submit-form action (see 12.7.5.2, "Submit-Form Action").
+     */
+    AcroFieldFlags[AcroFieldFlags["Required"] = flag(2 - 1)] = "Required";
+    /**
+     * If set, the field shall not be exported by a submit-form action
+     * (see 12.7.5.2, "Submit-Form Action").
+     */
+    AcroFieldFlags[AcroFieldFlags["NoExport"] = flag(3 - 1)] = "NoExport";
+})(exports.AcroFieldFlags || (exports.AcroFieldFlags = {}));
+/** From PDF spec table 226 */
+exports.AcroButtonFlags = void 0;
+(function (AcroButtonFlags) {
+    /**
+     * (Radio buttons only) If set, exactly one radio button shall be selected at
+     * all times; selecting the currently selected button has no effect. If clear,
+     * clicking the selected button deselects it, leaving no button selected.
+     */
+    AcroButtonFlags[AcroButtonFlags["NoToggleToOff"] = flag(15 - 1)] = "NoToggleToOff";
+    /**
+     * If set, the field is a set of radio buttons; if clear, the field is a check
+     * box. This flag may be set only if the Pushbutton flag is clear.
+     */
+    AcroButtonFlags[AcroButtonFlags["Radio"] = flag(16 - 1)] = "Radio";
+    /**
+     * If set, the field is a pushbutton that does not retain a permanent value.
+     */
+    AcroButtonFlags[AcroButtonFlags["PushButton"] = flag(17 - 1)] = "PushButton";
+    /**
+     * If set, a group of radio buttons within a radio button field that use the
+     * same value for the on state will turn on and off in unison; that is if one
+     * is checked, they are all checked. If clear, the buttons are mutually
+     * exclusive (the same behavior as HTML radio buttons).
+     */
+    AcroButtonFlags[AcroButtonFlags["RadiosInUnison"] = flag(26 - 1)] = "RadiosInUnison";
+})(exports.AcroButtonFlags || (exports.AcroButtonFlags = {}));
+/** From PDF spec table 228 */
+exports.AcroTextFlags = void 0;
+(function (AcroTextFlags) {
+    /**
+     * If set, the field may contain multiple lines of text; if clear, the field's
+     * text shall be restricted to a single line.
+     */
+    AcroTextFlags[AcroTextFlags["Multiline"] = flag(13 - 1)] = "Multiline";
+    /**
+     * If set, the field is intended for entering a secure password that should
+     * not be echoed visibly to the screen. Characters typed from the keyboard
+     * shall instead be echoed in some unreadable form, such as asterisks or
+     * bullet characters.
+     * > NOTE   To protect password confidentiality, readers should never store
+     * >        the value of the text field in the PDF file if this flag is set.
+     */
+    AcroTextFlags[AcroTextFlags["Password"] = flag(14 - 1)] = "Password";
+    /**
+     * If set, the text entered in the field represents the pathname of a file
+     * whose contents shall be submitted as the value of the field.
+     */
+    AcroTextFlags[AcroTextFlags["FileSelect"] = flag(21 - 1)] = "FileSelect";
+    /**
+     * If set, text entered in the field shall not be spell-checked.
+     */
+    AcroTextFlags[AcroTextFlags["DoNotSpellCheck"] = flag(23 - 1)] = "DoNotSpellCheck";
+    /**
+     * If set, the field shall not scroll (horizontally for single-line fields,
+     * vertically for multiple-line fields) to accommodate more text than fits
+     * within its annotation rectangle. Once the field is full, no further text
+     * shall be accepted for interactive form filling; for non-interactive form
+     * filling, the filler should take care not to add more character than will
+     * visibly fit in the defined area.
+     */
+    AcroTextFlags[AcroTextFlags["DoNotScroll"] = flag(24 - 1)] = "DoNotScroll";
+    /**
+     * May be set only if the MaxLen entry is present in the text field dictionary
+     * (see Table 229) and if the Multiline, Password, and FileSelect flags are
+     * clear. If set, the field shall be automatically divided into as many
+     * equally spaced positions, or combs, as the value of MaxLen, and the text
+     * is laid out into those combs.
+     */
+    AcroTextFlags[AcroTextFlags["Comb"] = flag(25 - 1)] = "Comb";
+    /**
+     * If set, the value of this field shall be a rich text string
+     * (see 12.7.3.4, "Rich Text Strings"). If the field has a value, the RV
+     * entry of the field dictionary (Table 222) shall specify the rich text
+     * string.
+     */
+    AcroTextFlags[AcroTextFlags["RichText"] = flag(26 - 1)] = "RichText";
+})(exports.AcroTextFlags || (exports.AcroTextFlags = {}));
+/** From PDF spec table 230 */
+exports.AcroChoiceFlags = void 0;
+(function (AcroChoiceFlags) {
+    /**
+     * If set, the field is a combo box; if clear, the field is a list box.
+     */
+    AcroChoiceFlags[AcroChoiceFlags["Combo"] = flag(18 - 1)] = "Combo";
+    /**
+     * If set, the combo box shall include an editable text box as well as a
+     * drop-down list; if clear, it shall include only a drop-down list. This
+     * flag shall be used only if the Combo flag is set.
+     */
+    AcroChoiceFlags[AcroChoiceFlags["Edit"] = flag(19 - 1)] = "Edit";
+    /**
+     * If set, the field's option items shall be sorted alphabetically. This flag
+     * is intended for use by writers, not by readers. Conforming readers shall
+     * display the options in the order in which they occur in the Opt array
+     * (see Table 231).
+     */
+    AcroChoiceFlags[AcroChoiceFlags["Sort"] = flag(20 - 1)] = "Sort";
+    /**
+     * If set, more than one of the field's option items may be selected
+     * simultaneously; if clear, at most one item shall be selected.
+     */
+    AcroChoiceFlags[AcroChoiceFlags["MultiSelect"] = flag(22 - 1)] = "MultiSelect";
+    /**
+     * If set, text entered in the field shall not be spell-checked. This flag
+     * shall not be used unless the Combo and Edit flags are both set.
+     */
+    AcroChoiceFlags[AcroChoiceFlags["DoNotSpellCheck"] = flag(23 - 1)] = "DoNotSpellCheck";
+    /**
+     * If set, the new value shall be committed as soon as a selection is made
+     * (commonly with the pointing device). In this case, supplying a value for
+     * a field involves three actions: selecting the field for fill-in,
+     * selecting a choice for the fill-in value, and leaving that field, which
+     * finalizes or "commits" the data choice and triggers any actions associated
+     * with the entry or changing of this data. If this flag is on, then
+     * processing does not wait for leaving the field action to occur, but
+     * immediately proceeds to the third step.
+     *
+     * This option enables applications to perform an action once a selection is
+     * made, without requiring the user to exit the field. If clear, the new
+     * value is not committed until the user exits the field.
+     */
+    AcroChoiceFlags[AcroChoiceFlags["CommitOnSelChange"] = flag(27 - 1)] = "CommitOnSelChange";
+})(exports.AcroChoiceFlags || (exports.AcroChoiceFlags = {}));

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

@@ -0,0 +1,128 @@
+'use strict';
+
+var PDFNumber = require('../objects/PDFNumber.js');
+var PDFDict = require('../objects/PDFDict.js');
+var PDFName = require('../objects/PDFName.js');
+var PDFArray = require('../objects/PDFArray.js');
+var PDFRef = require('../objects/PDFRef.js');
+var PDFAcroTerminal = require('./PDFAcroTerminal.js');
+var PDFAcroNonTerminal = require('./PDFAcroNonTerminal.js');
+var PDFAcroSignature = require('./PDFAcroSignature.js');
+var PDFAcroText = require('./PDFAcroText.js');
+var PDFAcroPushButton = require('./PDFAcroPushButton.js');
+var PDFAcroRadioButton = require('./PDFAcroRadioButton.js');
+var PDFAcroCheckBox = require('./PDFAcroCheckBox.js');
+var PDFAcroComboBox = require('./PDFAcroComboBox.js');
+var PDFAcroListBox = require('./PDFAcroListBox.js');
+var flags = require('./flags.js');
+
+var createPDFAcroFields = function (kidDicts) {
+    if (!kidDicts)
+        return [];
+    var kids = [];
+    for (var idx = 0, len = kidDicts.size(); idx < len; idx++) {
+        var ref = kidDicts.get(idx);
+        var dict = kidDicts.lookup(idx);
+        // if (dict instanceof PDFDict) kids.push(PDFAcroField.fromDict(dict));
+        if (ref instanceof PDFRef.default && dict instanceof PDFDict.default) {
+            kids.push([createPDFAcroField(dict, ref), ref]);
+        }
+    }
+    return kids;
+};
+var createPDFAcroField = function (dict, ref) {
+    var isNonTerminal = isNonTerminalAcroField(dict);
+    if (isNonTerminal)
+        return PDFAcroNonTerminal.default.fromDict(dict, ref);
+    return createPDFAcroTerminal(dict, ref);
+};
+// TODO: Maybe just check if the dict is *not* a widget? That might be better.
+// According to the PDF spec:
+//
+//   > A field's children in the hierarchy may also include widget annotations
+//   > that define its appearance on the page. A field that has children that
+//   > are fields is called a non-terminal field. A field that does not have
+//   > children that are fields is called a terminal field.
+//
+// The spec is not entirely clear about how to determine whether a given
+// dictionary represents an acrofield or a widget annotation. So we will assume
+// that a dictionary is an acrofield if it is a member of the `/Kids` array
+// and it contains a `/T` entry (widgets do not have `/T` entries). This isn't
+// a bullet proof solution, because the `/T` entry is technically defined as
+// optional for acrofields by the PDF spec. But in practice all acrofields seem
+// to have a `/T` entry defined.
+var isNonTerminalAcroField = function (dict) {
+    var kids = dict.lookup(PDFName.default.of('Kids'));
+    if (kids instanceof PDFArray.default) {
+        for (var idx = 0, len = kids.size(); idx < len; idx++) {
+            var kid = kids.lookup(idx);
+            var kidIsField = kid instanceof PDFDict.default && kid.has(PDFName.default.of('T'));
+            if (kidIsField)
+                return true;
+        }
+    }
+    return false;
+};
+var createPDFAcroTerminal = function (dict, ref) {
+    var ftNameOrRef = getInheritableAttribute(dict, PDFName.default.of('FT'));
+    var type = dict.context.lookup(ftNameOrRef, PDFName.default);
+    if (type === PDFName.default.of('Btn'))
+        return createPDFAcroButton(dict, ref);
+    if (type === PDFName.default.of('Ch'))
+        return createPDFAcroChoice(dict, ref);
+    if (type === PDFName.default.of('Tx'))
+        return PDFAcroText.default.fromDict(dict, ref);
+    if (type === PDFName.default.of('Sig'))
+        return PDFAcroSignature.default.fromDict(dict, ref);
+    // We should never reach this line. But there are a lot of weird PDFs out
+    // there. So, just to be safe, we'll try to handle things gracefully instead
+    // of throwing an error.
+    return PDFAcroTerminal.default.fromDict(dict, ref);
+};
+var createPDFAcroButton = function (dict, ref) {
+    var _a;
+    var ffNumberOrRef = getInheritableAttribute(dict, PDFName.default.of('Ff'));
+    var ffNumber = dict.context.lookupMaybe(ffNumberOrRef, PDFNumber.default);
+    var flags$1 = (_a = ffNumber === null || ffNumber === void 0 ? void 0 : ffNumber.asNumber()) !== null && _a !== void 0 ? _a : 0;
+    if (flagIsSet(flags$1, flags.AcroButtonFlags.PushButton)) {
+        return PDFAcroPushButton.default.fromDict(dict, ref);
+    }
+    else if (flagIsSet(flags$1, flags.AcroButtonFlags.Radio)) {
+        return PDFAcroRadioButton.default.fromDict(dict, ref);
+    }
+    else {
+        return PDFAcroCheckBox.default.fromDict(dict, ref);
+    }
+};
+var createPDFAcroChoice = function (dict, ref) {
+    var _a;
+    var ffNumberOrRef = getInheritableAttribute(dict, PDFName.default.of('Ff'));
+    var ffNumber = dict.context.lookupMaybe(ffNumberOrRef, PDFNumber.default);
+    var flags$1 = (_a = ffNumber === null || ffNumber === void 0 ? void 0 : ffNumber.asNumber()) !== null && _a !== void 0 ? _a : 0;
+    if (flagIsSet(flags$1, flags.AcroChoiceFlags.Combo)) {
+        return PDFAcroComboBox.default.fromDict(dict, ref);
+    }
+    else {
+        return PDFAcroListBox.default.fromDict(dict, ref);
+    }
+};
+var flagIsSet = function (flags, flag) {
+    return (flags & flag) !== 0;
+};
+var getInheritableAttribute = function (startNode, name) {
+    var attribute;
+    ascend(startNode, function (node) {
+        if (!attribute)
+            attribute = node.get(name);
+    });
+    return attribute;
+};
+var ascend = function (startNode, visitor) {
+    visitor(startNode);
+    var Parent = startNode.lookupMaybe(PDFName.default.of('Parent'), PDFDict.default);
+    if (Parent)
+        ascend(Parent, visitor);
+};
+
+exports.createPDFAcroField = createPDFAcroField;
+exports.createPDFAcroFields = createPDFAcroFields;

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

@@ -0,0 +1,125 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+var PDFName = require('../objects/PDFName.js');
+var PDFNumber = require('../objects/PDFNumber.js');
+var PDFArray = require('../objects/PDFArray.js');
+var PDFHexString = require('../objects/PDFHexString.js');
+var PDFString = require('../objects/PDFString.js');
+
+var AppearanceCharacteristics = /** @class */ (function () {
+    function AppearanceCharacteristics(dict) {
+        this.dict = dict;
+    }
+    AppearanceCharacteristics.prototype.R = function () {
+        var R = this.dict.lookup(PDFName.default.of('R'));
+        if (R instanceof PDFNumber.default)
+            return R;
+        return undefined;
+    };
+    AppearanceCharacteristics.prototype.BC = function () {
+        var BC = this.dict.lookup(PDFName.default.of('BC'));
+        if (BC instanceof PDFArray.default)
+            return BC;
+        return undefined;
+    };
+    AppearanceCharacteristics.prototype.BG = function () {
+        var BG = this.dict.lookup(PDFName.default.of('BG'));
+        if (BG instanceof PDFArray.default)
+            return BG;
+        return undefined;
+    };
+    AppearanceCharacteristics.prototype.CA = function () {
+        var CA = this.dict.lookup(PDFName.default.of('CA'));
+        if (CA instanceof PDFHexString.default || CA instanceof PDFString.default)
+            return CA;
+        return undefined;
+    };
+    AppearanceCharacteristics.prototype.RC = function () {
+        var RC = this.dict.lookup(PDFName.default.of('RC'));
+        if (RC instanceof PDFHexString.default || RC instanceof PDFString.default)
+            return RC;
+        return undefined;
+    };
+    AppearanceCharacteristics.prototype.AC = function () {
+        var AC = this.dict.lookup(PDFName.default.of('AC'));
+        if (AC instanceof PDFHexString.default || AC instanceof PDFString.default)
+            return AC;
+        return undefined;
+    };
+    AppearanceCharacteristics.prototype.getRotation = function () {
+        var _a;
+        return (_a = this.R()) === null || _a === void 0 ? void 0 : _a.asNumber();
+    };
+    AppearanceCharacteristics.prototype.getBorderColor = function () {
+        var BC = this.BC();
+        if (!BC)
+            return undefined;
+        var components = [];
+        for (var idx = 0, len = BC === null || BC === void 0 ? void 0 : BC.size(); idx < len; idx++) {
+            var component = BC.get(idx);
+            if (component instanceof PDFNumber.default)
+                components.push(component.asNumber());
+        }
+        return components;
+    };
+    AppearanceCharacteristics.prototype.getBackgroundColor = function () {
+        var BG = this.BG();
+        if (!BG)
+            return undefined;
+        var components = [];
+        for (var idx = 0, len = BG === null || BG === void 0 ? void 0 : BG.size(); idx < len; idx++) {
+            var component = BG.get(idx);
+            if (component instanceof PDFNumber.default)
+                components.push(component.asNumber());
+        }
+        return components;
+    };
+    AppearanceCharacteristics.prototype.getCaptions = function () {
+        var CA = this.CA();
+        var RC = this.RC();
+        var AC = this.AC();
+        return {
+            normal: CA === null || CA === void 0 ? void 0 : CA.decodeText(),
+            rollover: RC === null || RC === void 0 ? void 0 : RC.decodeText(),
+            down: AC === null || AC === void 0 ? void 0 : AC.decodeText(),
+        };
+    };
+    AppearanceCharacteristics.prototype.setRotation = function (rotation) {
+        var R = this.dict.context.obj(rotation);
+        this.dict.set(PDFName.default.of('R'), R);
+    };
+    AppearanceCharacteristics.prototype.setBorderColor = function (color) {
+        var BC = this.dict.context.obj(color);
+        this.dict.set(PDFName.default.of('BC'), BC);
+    };
+    AppearanceCharacteristics.prototype.setBackgroundColor = function (color) {
+        var BG = this.dict.context.obj(color);
+        this.dict.set(PDFName.default.of('BG'), BG);
+    };
+    AppearanceCharacteristics.prototype.setCaptions = function (captions) {
+        var CA = PDFHexString.default.fromText(captions.normal);
+        this.dict.set(PDFName.default.of('CA'), CA);
+        if (captions.rollover) {
+            var RC = PDFHexString.default.fromText(captions.rollover);
+            this.dict.set(PDFName.default.of('RC'), RC);
+        }
+        else {
+            this.dict.delete(PDFName.default.of('RC'));
+        }
+        if (captions.down) {
+            var AC = PDFHexString.default.fromText(captions.down);
+            this.dict.set(PDFName.default.of('AC'), AC);
+        }
+        else {
+            this.dict.delete(PDFName.default.of('AC'));
+        }
+    };
+    AppearanceCharacteristics.fromDict = function (dict) {
+        return new AppearanceCharacteristics(dict);
+    };
+    return AppearanceCharacteristics;
+}());
+
+exports.default = AppearanceCharacteristics;

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

@@ -0,0 +1,31 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+var PDFName = require('../objects/PDFName.js');
+var PDFNumber = require('../objects/PDFNumber.js');
+
+// TODO: Also handle the `/S` and `/D` entries
+var BorderStyle = /** @class */ (function () {
+    function BorderStyle(dict) {
+        this.dict = dict;
+    }
+    BorderStyle.prototype.W = function () {
+        var W = this.dict.lookup(PDFName.default.of('W'));
+        if (W instanceof PDFNumber.default)
+            return W;
+        return undefined;
+    };
+    BorderStyle.prototype.getWidth = function () {
+        var _a, _b;
+        return (_b = (_a = this.W()) === null || _a === void 0 ? void 0 : _a.asNumber()) !== null && _b !== void 0 ? _b : 1;
+    };
+    BorderStyle.prototype.setWidth = function (width) {
+        var W = this.dict.context.obj(width);
+        this.dict.set(PDFName.default.of('W'), W);
+    };
+    BorderStyle.fromDict = function (dict) { return new BorderStyle(dict); };
+    return BorderStyle;
+}());
+
+exports.default = BorderStyle;

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

@@ -0,0 +1,125 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+var PDFDict = require('../objects/PDFDict.js');
+var PDFName = require('../objects/PDFName.js');
+var PDFStream = require('../objects/PDFStream.js');
+var PDFArray = require('../objects/PDFArray.js');
+var PDFRef = require('../objects/PDFRef.js');
+var PDFNumber = require('../objects/PDFNumber.js');
+
+var PDFAnnotation = /** @class */ (function () {
+    function PDFAnnotation(dict) {
+        this.dict = dict;
+    }
+    // This is technically required by the PDF spec
+    PDFAnnotation.prototype.Rect = function () {
+        return this.dict.lookup(PDFName.default.of('Rect'), PDFArray.default);
+    };
+    PDFAnnotation.prototype.AP = function () {
+        return this.dict.lookupMaybe(PDFName.default.of('AP'), PDFDict.default);
+    };
+    PDFAnnotation.prototype.F = function () {
+        var numberOrRef = this.dict.lookup(PDFName.default.of('F'));
+        return this.dict.context.lookupMaybe(numberOrRef, PDFNumber.default);
+    };
+    PDFAnnotation.prototype.getRectangle = function () {
+        var _a;
+        var Rect = this.Rect();
+        return (_a = Rect === null || Rect === void 0 ? void 0 : Rect.asRectangle()) !== null && _a !== void 0 ? _a : { x: 0, y: 0, width: 0, height: 0 };
+    };
+    PDFAnnotation.prototype.setRectangle = function (rect) {
+        var x = rect.x, y = rect.y, width = rect.width, height = rect.height;
+        var Rect = this.dict.context.obj([x, y, x + width, y + height]);
+        this.dict.set(PDFName.default.of('Rect'), Rect);
+    };
+    PDFAnnotation.prototype.getAppearanceState = function () {
+        var AS = this.dict.lookup(PDFName.default.of('AS'));
+        if (AS instanceof PDFName.default)
+            return AS;
+        return undefined;
+    };
+    PDFAnnotation.prototype.setAppearanceState = function (state) {
+        this.dict.set(PDFName.default.of('AS'), state);
+    };
+    PDFAnnotation.prototype.setAppearances = function (appearances) {
+        this.dict.set(PDFName.default.of('AP'), appearances);
+    };
+    PDFAnnotation.prototype.ensureAP = function () {
+        var AP = this.AP();
+        if (!AP) {
+            AP = this.dict.context.obj({});
+            this.dict.set(PDFName.default.of('AP'), AP);
+        }
+        return AP;
+    };
+    PDFAnnotation.prototype.getNormalAppearance = function () {
+        var AP = this.ensureAP();
+        var N = AP.get(PDFName.default.of('N'));
+        if (N instanceof PDFRef.default || N instanceof PDFDict.default)
+            return N;
+        throw new Error("Unexpected N type: " + (N === null || N === void 0 ? void 0 : N.constructor.name));
+    };
+    /** @param appearance A PDFDict or PDFStream (direct or ref) */
+    PDFAnnotation.prototype.setNormalAppearance = function (appearance) {
+        var AP = this.ensureAP();
+        AP.set(PDFName.default.of('N'), appearance);
+    };
+    /** @param appearance A PDFDict or PDFStream (direct or ref) */
+    PDFAnnotation.prototype.setRolloverAppearance = function (appearance) {
+        var AP = this.ensureAP();
+        AP.set(PDFName.default.of('R'), appearance);
+    };
+    /** @param appearance A PDFDict or PDFStream (direct or ref) */
+    PDFAnnotation.prototype.setDownAppearance = function (appearance) {
+        var AP = this.ensureAP();
+        AP.set(PDFName.default.of('D'), appearance);
+    };
+    PDFAnnotation.prototype.removeRolloverAppearance = function () {
+        var AP = this.AP();
+        AP === null || AP === void 0 ? void 0 : AP.delete(PDFName.default.of('R'));
+    };
+    PDFAnnotation.prototype.removeDownAppearance = function () {
+        var AP = this.AP();
+        AP === null || AP === void 0 ? void 0 : AP.delete(PDFName.default.of('D'));
+    };
+    PDFAnnotation.prototype.getAppearances = function () {
+        var AP = this.AP();
+        if (!AP)
+            return undefined;
+        var N = AP.lookup(PDFName.default.of('N'), PDFDict.default, PDFStream.default);
+        var R = AP.lookupMaybe(PDFName.default.of('R'), PDFDict.default, PDFStream.default);
+        var D = AP.lookupMaybe(PDFName.default.of('D'), PDFDict.default, PDFStream.default);
+        return { normal: N, rollover: R, down: D };
+    };
+    PDFAnnotation.prototype.getFlags = function () {
+        var _a, _b;
+        return (_b = (_a = this.F()) === null || _a === void 0 ? void 0 : _a.asNumber()) !== null && _b !== void 0 ? _b : 0;
+    };
+    PDFAnnotation.prototype.setFlags = function (flags) {
+        this.dict.set(PDFName.default.of('F'), PDFNumber.default.of(flags));
+    };
+    PDFAnnotation.prototype.hasFlag = function (flag) {
+        var flags = this.getFlags();
+        return (flags & flag) !== 0;
+    };
+    PDFAnnotation.prototype.setFlag = function (flag) {
+        var flags = this.getFlags();
+        this.setFlags(flags | flag);
+    };
+    PDFAnnotation.prototype.clearFlag = function (flag) {
+        var flags = this.getFlags();
+        this.setFlags(flags & ~flag);
+    };
+    PDFAnnotation.prototype.setFlagTo = function (flag, enable) {
+        if (enable)
+            this.setFlag(flag);
+        else
+            this.clearFlag(flag);
+    };
+    PDFAnnotation.fromDict = function (dict) { return new PDFAnnotation(dict); };
+    return PDFAnnotation;
+}());
+
+exports.default = PDFAnnotation;

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

@@ -0,0 +1,113 @@
+'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 PDFRef = require('../objects/PDFRef.js');
+var PDFString = require('../objects/PDFString.js');
+var PDFHexString = require('../objects/PDFHexString.js');
+var BorderStyle = require('./BorderStyle.js');
+var PDFAnnotation = require('./PDFAnnotation.js');
+var AppearanceCharacteristics = require('./AppearanceCharacteristics.js');
+
+var PDFWidgetAnnotation = /** @class */ (function (_super) {
+    tslib_es6.__extends(PDFWidgetAnnotation, _super);
+    function PDFWidgetAnnotation() {
+        return _super !== null && _super.apply(this, arguments) || this;
+    }
+    PDFWidgetAnnotation.prototype.MK = function () {
+        var MK = this.dict.lookup(PDFName.default.of('MK'));
+        if (MK instanceof PDFDict.default)
+            return MK;
+        return undefined;
+    };
+    PDFWidgetAnnotation.prototype.BS = function () {
+        var BS = this.dict.lookup(PDFName.default.of('BS'));
+        if (BS instanceof PDFDict.default)
+            return BS;
+        return undefined;
+    };
+    PDFWidgetAnnotation.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;
+    };
+    PDFWidgetAnnotation.prototype.P = function () {
+        var P = this.dict.get(PDFName.default.of('P'));
+        if (P instanceof PDFRef.default)
+            return P;
+        return undefined;
+    };
+    PDFWidgetAnnotation.prototype.setP = function (page) {
+        this.dict.set(PDFName.default.of('P'), page);
+    };
+    PDFWidgetAnnotation.prototype.setDefaultAppearance = function (appearance) {
+        this.dict.set(PDFName.default.of('DA'), PDFString.default.of(appearance));
+    };
+    PDFWidgetAnnotation.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();
+    };
+    PDFWidgetAnnotation.prototype.getAppearanceCharacteristics = function () {
+        var MK = this.MK();
+        if (MK)
+            return AppearanceCharacteristics.default.fromDict(MK);
+        return undefined;
+    };
+    PDFWidgetAnnotation.prototype.getOrCreateAppearanceCharacteristics = function () {
+        var MK = this.MK();
+        if (MK)
+            return AppearanceCharacteristics.default.fromDict(MK);
+        var ac = AppearanceCharacteristics.default.fromDict(this.dict.context.obj({}));
+        this.dict.set(PDFName.default.of('MK'), ac.dict);
+        return ac;
+    };
+    PDFWidgetAnnotation.prototype.getBorderStyle = function () {
+        var BS = this.BS();
+        if (BS)
+            return BorderStyle.default.fromDict(BS);
+        return undefined;
+    };
+    PDFWidgetAnnotation.prototype.getOrCreateBorderStyle = function () {
+        var BS = this.BS();
+        if (BS)
+            return BorderStyle.default.fromDict(BS);
+        var bs = BorderStyle.default.fromDict(this.dict.context.obj({}));
+        this.dict.set(PDFName.default.of('BS'), bs.dict);
+        return bs;
+    };
+    PDFWidgetAnnotation.prototype.getOnValue = function () {
+        var _a;
+        var normal = (_a = this.getAppearances()) === null || _a === void 0 ? void 0 : _a.normal;
+        if (normal instanceof PDFDict.default) {
+            var keys = normal.keys();
+            for (var idx = 0, len = keys.length; idx < len; idx++) {
+                var key = keys[idx];
+                if (key !== PDFName.default.of('Off'))
+                    return key;
+            }
+        }
+        return undefined;
+    };
+    PDFWidgetAnnotation.fromDict = function (dict) {
+        return new PDFWidgetAnnotation(dict);
+    };
+    PDFWidgetAnnotation.create = function (context, parent) {
+        var dict = context.obj({
+            Type: 'Annot',
+            Subtype: 'Widget',
+            Rect: [0, 0, 0, 0],
+            Parent: parent,
+        });
+        return new PDFWidgetAnnotation(dict);
+    };
+    return PDFWidgetAnnotation;
+}(PDFAnnotation.default));
+
+exports.default = PDFWidgetAnnotation;