art-bd-ui 1.0.21 → 1.0.23

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

@@ -0,0 +1,72 @@
+import { __extends } from '../../../../tslib/tslib.es6.js';
+import PDFNumber from '../objects/PDFNumber.js';
+import PDFString from '../objects/PDFString.js';
+import PDFHexString from '../objects/PDFHexString.js';
+import PDFName from '../objects/PDFName.js';
+import PDFAcroTerminal from './PDFAcroTerminal.js';
+
+var PDFAcroText = /** @class */ (function (_super) {
+    __extends(PDFAcroText, _super);
+    function PDFAcroText() {
+        return _super !== null && _super.apply(this, arguments) || this;
+    }
+    PDFAcroText.prototype.MaxLen = function () {
+        var maxLen = this.dict.lookup(PDFName.of('MaxLen'));
+        if (maxLen instanceof PDFNumber)
+            return maxLen;
+        return undefined;
+    };
+    PDFAcroText.prototype.Q = function () {
+        var q = this.dict.lookup(PDFName.of('Q'));
+        if (q instanceof PDFNumber)
+            return q;
+        return undefined;
+    };
+    PDFAcroText.prototype.setMaxLength = function (maxLength) {
+        this.dict.set(PDFName.of('MaxLen'), PDFNumber.of(maxLength));
+    };
+    PDFAcroText.prototype.removeMaxLength = function () {
+        this.dict.delete(PDFName.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.of('Q'), PDFNumber.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.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.of('V'));
+    };
+    PDFAcroText.prototype.getValue = function () {
+        var v = this.V();
+        if (v instanceof PDFString || v instanceof PDFHexString)
+            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));
+
+export { PDFAcroText as default };

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

@@ -0,0 +1,148 @@
+var flag = function (bitIndex) { return 1 << bitIndex; };
+/** From PDF spec table 221 */
+var AcroFieldFlags;
+(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";
+})(AcroFieldFlags || (AcroFieldFlags = {}));
+/** From PDF spec table 226 */
+var AcroButtonFlags;
+(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";
+})(AcroButtonFlags || (AcroButtonFlags = {}));
+/** From PDF spec table 228 */
+var AcroTextFlags;
+(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";
+})(AcroTextFlags || (AcroTextFlags = {}));
+/** From PDF spec table 230 */
+var AcroChoiceFlags;
+(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";
+})(AcroChoiceFlags || (AcroChoiceFlags = {}));
+
+export { AcroButtonFlags, AcroChoiceFlags, AcroFieldFlags, AcroTextFlags };

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

@@ -0,0 +1,125 @@
+import PDFNumber from '../objects/PDFNumber.js';
+import PDFDict from '../objects/PDFDict.js';
+import PDFName from '../objects/PDFName.js';
+import PDFArray from '../objects/PDFArray.js';
+import PDFRef from '../objects/PDFRef.js';
+import PDFAcroTerminal from './PDFAcroTerminal.js';
+import PDFAcroNonTerminal from './PDFAcroNonTerminal.js';
+import PDFAcroSignature from './PDFAcroSignature.js';
+import PDFAcroText from './PDFAcroText.js';
+import PDFAcroPushButton from './PDFAcroPushButton.js';
+import PDFAcroRadioButton from './PDFAcroRadioButton.js';
+import PDFAcroCheckBox from './PDFAcroCheckBox.js';
+import PDFAcroComboBox from './PDFAcroComboBox.js';
+import PDFAcroListBox from './PDFAcroListBox.js';
+import { AcroButtonFlags, AcroChoiceFlags } from './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 && dict instanceof PDFDict) {
+            kids.push([createPDFAcroField(dict, ref), ref]);
+        }
+    }
+    return kids;
+};
+var createPDFAcroField = function (dict, ref) {
+    var isNonTerminal = isNonTerminalAcroField(dict);
+    if (isNonTerminal)
+        return PDFAcroNonTerminal.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.of('Kids'));
+    if (kids instanceof PDFArray) {
+        for (var idx = 0, len = kids.size(); idx < len; idx++) {
+            var kid = kids.lookup(idx);
+            var kidIsField = kid instanceof PDFDict && kid.has(PDFName.of('T'));
+            if (kidIsField)
+                return true;
+        }
+    }
+    return false;
+};
+var createPDFAcroTerminal = function (dict, ref) {
+    var ftNameOrRef = getInheritableAttribute(dict, PDFName.of('FT'));
+    var type = dict.context.lookup(ftNameOrRef, PDFName);
+    if (type === PDFName.of('Btn'))
+        return createPDFAcroButton(dict, ref);
+    if (type === PDFName.of('Ch'))
+        return createPDFAcroChoice(dict, ref);
+    if (type === PDFName.of('Tx'))
+        return PDFAcroText.fromDict(dict, ref);
+    if (type === PDFName.of('Sig'))
+        return PDFAcroSignature.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.fromDict(dict, ref);
+};
+var createPDFAcroButton = function (dict, ref) {
+    var _a;
+    var ffNumberOrRef = getInheritableAttribute(dict, PDFName.of('Ff'));
+    var ffNumber = dict.context.lookupMaybe(ffNumberOrRef, PDFNumber);
+    var flags = (_a = ffNumber === null || ffNumber === void 0 ? void 0 : ffNumber.asNumber()) !== null && _a !== void 0 ? _a : 0;
+    if (flagIsSet(flags, AcroButtonFlags.PushButton)) {
+        return PDFAcroPushButton.fromDict(dict, ref);
+    }
+    else if (flagIsSet(flags, AcroButtonFlags.Radio)) {
+        return PDFAcroRadioButton.fromDict(dict, ref);
+    }
+    else {
+        return PDFAcroCheckBox.fromDict(dict, ref);
+    }
+};
+var createPDFAcroChoice = function (dict, ref) {
+    var _a;
+    var ffNumberOrRef = getInheritableAttribute(dict, PDFName.of('Ff'));
+    var ffNumber = dict.context.lookupMaybe(ffNumberOrRef, PDFNumber);
+    var flags = (_a = ffNumber === null || ffNumber === void 0 ? void 0 : ffNumber.asNumber()) !== null && _a !== void 0 ? _a : 0;
+    if (flagIsSet(flags, AcroChoiceFlags.Combo)) {
+        return PDFAcroComboBox.fromDict(dict, ref);
+    }
+    else {
+        return PDFAcroListBox.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.of('Parent'), PDFDict);
+    if (Parent)
+        ascend(Parent, visitor);
+};
+
+export { createPDFAcroField, createPDFAcroFields };

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

@@ -0,0 +1,121 @@
+import PDFName from '../objects/PDFName.js';
+import PDFNumber from '../objects/PDFNumber.js';
+import PDFArray from '../objects/PDFArray.js';
+import PDFHexString from '../objects/PDFHexString.js';
+import PDFString from '../objects/PDFString.js';
+
+var AppearanceCharacteristics = /** @class */ (function () {
+    function AppearanceCharacteristics(dict) {
+        this.dict = dict;
+    }
+    AppearanceCharacteristics.prototype.R = function () {
+        var R = this.dict.lookup(PDFName.of('R'));
+        if (R instanceof PDFNumber)
+            return R;
+        return undefined;
+    };
+    AppearanceCharacteristics.prototype.BC = function () {
+        var BC = this.dict.lookup(PDFName.of('BC'));
+        if (BC instanceof PDFArray)
+            return BC;
+        return undefined;
+    };
+    AppearanceCharacteristics.prototype.BG = function () {
+        var BG = this.dict.lookup(PDFName.of('BG'));
+        if (BG instanceof PDFArray)
+            return BG;
+        return undefined;
+    };
+    AppearanceCharacteristics.prototype.CA = function () {
+        var CA = this.dict.lookup(PDFName.of('CA'));
+        if (CA instanceof PDFHexString || CA instanceof PDFString)
+            return CA;
+        return undefined;
+    };
+    AppearanceCharacteristics.prototype.RC = function () {
+        var RC = this.dict.lookup(PDFName.of('RC'));
+        if (RC instanceof PDFHexString || RC instanceof PDFString)
+            return RC;
+        return undefined;
+    };
+    AppearanceCharacteristics.prototype.AC = function () {
+        var AC = this.dict.lookup(PDFName.of('AC'));
+        if (AC instanceof PDFHexString || AC instanceof PDFString)
+            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)
+                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)
+                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.of('R'), R);
+    };
+    AppearanceCharacteristics.prototype.setBorderColor = function (color) {
+        var BC = this.dict.context.obj(color);
+        this.dict.set(PDFName.of('BC'), BC);
+    };
+    AppearanceCharacteristics.prototype.setBackgroundColor = function (color) {
+        var BG = this.dict.context.obj(color);
+        this.dict.set(PDFName.of('BG'), BG);
+    };
+    AppearanceCharacteristics.prototype.setCaptions = function (captions) {
+        var CA = PDFHexString.fromText(captions.normal);
+        this.dict.set(PDFName.of('CA'), CA);
+        if (captions.rollover) {
+            var RC = PDFHexString.fromText(captions.rollover);
+            this.dict.set(PDFName.of('RC'), RC);
+        }
+        else {
+            this.dict.delete(PDFName.of('RC'));
+        }
+        if (captions.down) {
+            var AC = PDFHexString.fromText(captions.down);
+            this.dict.set(PDFName.of('AC'), AC);
+        }
+        else {
+            this.dict.delete(PDFName.of('AC'));
+        }
+    };
+    AppearanceCharacteristics.fromDict = function (dict) {
+        return new AppearanceCharacteristics(dict);
+    };
+    return AppearanceCharacteristics;
+}());
+
+export { AppearanceCharacteristics as default };

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

@@ -0,0 +1,27 @@
+import PDFName from '../objects/PDFName.js';
+import PDFNumber from '../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.of('W'));
+        if (W instanceof PDFNumber)
+            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.of('W'), W);
+    };
+    BorderStyle.fromDict = function (dict) { return new BorderStyle(dict); };
+    return BorderStyle;
+}());
+
+export { BorderStyle as default };

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

@@ -0,0 +1,121 @@
+import PDFDict from '../objects/PDFDict.js';
+import PDFName from '../objects/PDFName.js';
+import PDFStream from '../objects/PDFStream.js';
+import PDFArray from '../objects/PDFArray.js';
+import PDFRef from '../objects/PDFRef.js';
+import PDFNumber from '../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.of('Rect'), PDFArray);
+    };
+    PDFAnnotation.prototype.AP = function () {
+        return this.dict.lookupMaybe(PDFName.of('AP'), PDFDict);
+    };
+    PDFAnnotation.prototype.F = function () {
+        var numberOrRef = this.dict.lookup(PDFName.of('F'));
+        return this.dict.context.lookupMaybe(numberOrRef, PDFNumber);
+    };
+    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.of('Rect'), Rect);
+    };
+    PDFAnnotation.prototype.getAppearanceState = function () {
+        var AS = this.dict.lookup(PDFName.of('AS'));
+        if (AS instanceof PDFName)
+            return AS;
+        return undefined;
+    };
+    PDFAnnotation.prototype.setAppearanceState = function (state) {
+        this.dict.set(PDFName.of('AS'), state);
+    };
+    PDFAnnotation.prototype.setAppearances = function (appearances) {
+        this.dict.set(PDFName.of('AP'), appearances);
+    };
+    PDFAnnotation.prototype.ensureAP = function () {
+        var AP = this.AP();
+        if (!AP) {
+            AP = this.dict.context.obj({});
+            this.dict.set(PDFName.of('AP'), AP);
+        }
+        return AP;
+    };
+    PDFAnnotation.prototype.getNormalAppearance = function () {
+        var AP = this.ensureAP();
+        var N = AP.get(PDFName.of('N'));
+        if (N instanceof PDFRef || N instanceof PDFDict)
+            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.of('N'), appearance);
+    };
+    /** @param appearance A PDFDict or PDFStream (direct or ref) */
+    PDFAnnotation.prototype.setRolloverAppearance = function (appearance) {
+        var AP = this.ensureAP();
+        AP.set(PDFName.of('R'), appearance);
+    };
+    /** @param appearance A PDFDict or PDFStream (direct or ref) */
+    PDFAnnotation.prototype.setDownAppearance = function (appearance) {
+        var AP = this.ensureAP();
+        AP.set(PDFName.of('D'), appearance);
+    };
+    PDFAnnotation.prototype.removeRolloverAppearance = function () {
+        var AP = this.AP();
+        AP === null || AP === void 0 ? void 0 : AP.delete(PDFName.of('R'));
+    };
+    PDFAnnotation.prototype.removeDownAppearance = function () {
+        var AP = this.AP();
+        AP === null || AP === void 0 ? void 0 : AP.delete(PDFName.of('D'));
+    };
+    PDFAnnotation.prototype.getAppearances = function () {
+        var AP = this.AP();
+        if (!AP)
+            return undefined;
+        var N = AP.lookup(PDFName.of('N'), PDFDict, PDFStream);
+        var R = AP.lookupMaybe(PDFName.of('R'), PDFDict, PDFStream);
+        var D = AP.lookupMaybe(PDFName.of('D'), PDFDict, PDFStream);
+        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.of('F'), PDFNumber.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;
+}());
+
+export { PDFAnnotation as default };