pdfjs-dist 2.0.943 → 2.1.266

package/lib/core/annotation.js

@@ -19,52 +19,68 @@
  * @licend The above is the entire license notice for the
  * Javascript code in this page
  */
-'use strict';
+"use strict";
 
 Object.defineProperty(exports, "__esModule", {
   value: true
 });
-exports.AnnotationFactory = exports.AnnotationBorderStyle = exports.Annotation = undefined;
+exports.AnnotationFactory = exports.AnnotationBorderStyle = exports.Annotation = void 0;
 
-var _get = function get(object, property, receiver) { if (object === null) object = Function.prototype; var desc = Object.getOwnPropertyDescriptor(object, property); if (desc === undefined) { var parent = Object.getPrototypeOf(object); if (parent === null) { return undefined; } else { return get(parent, property, receiver); } } else if ("value" in desc) { return desc.value; } else { var getter = desc.get; if (getter === undefined) { return undefined; } return getter.call(receiver); } };
+var _util = require("../shared/util");
 
-var _createClass = function () { function defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if ("value" in descriptor) descriptor.writable = true; Object.defineProperty(target, descriptor.key, descriptor); } } return function (Constructor, protoProps, staticProps) { if (protoProps) defineProperties(Constructor.prototype, protoProps); if (staticProps) defineProperties(Constructor, staticProps); return Constructor; }; }();
+var _obj = require("./obj");
 
-var _util = require('../shared/util');
+var _primitives = require("./primitives");
 
-var _obj = require('./obj');
+var _colorspace = require("./colorspace");
 
-var _primitives = require('./primitives');
+var _operator_list = require("./operator_list");
 
-var _colorspace = require('./colorspace');
+var _stream = require("./stream");
 
-var _operator_list = require('./operator_list');
+function _typeof(obj) { if (typeof Symbol === "function" && typeof Symbol.iterator === "symbol") { _typeof = function _typeof(obj) { return typeof obj; }; } else { _typeof = function _typeof(obj) { return obj && typeof Symbol === "function" && obj.constructor === Symbol && obj !== Symbol.prototype ? "symbol" : typeof obj; }; } return _typeof(obj); }
 
-var _stream = require('./stream');
+function _possibleConstructorReturn(self, call) { if (call && (_typeof(call) === "object" || typeof call === "function")) { return call; } return _assertThisInitialized(self); }
 
-function _possibleConstructorReturn(self, call) { if (!self) { throw new ReferenceError("this hasn't been initialised - super() hasn't been called"); } return call && (typeof call === "object" || typeof call === "function") ? call : self; }
+function _assertThisInitialized(self) { if (self === void 0) { throw new ReferenceError("this hasn't been initialised - super() hasn't been called"); } return self; }
 
-function _inherits(subClass, superClass) { if (typeof superClass !== "function" && superClass !== null) { throw new TypeError("Super expression must either be null or a function, not " + typeof superClass); } subClass.prototype = Object.create(superClass && superClass.prototype, { constructor: { value: subClass, enumerable: false, writable: true, configurable: true } }); if (superClass) Object.setPrototypeOf ? Object.setPrototypeOf(subClass, superClass) : subClass.__proto__ = superClass; }
+function _get(target, property, receiver) { if (typeof Reflect !== "undefined" && Reflect.get) { _get = Reflect.get; } else { _get = function _get(target, property, receiver) { var base = _superPropBase(target, property); if (!base) return; var desc = Object.getOwnPropertyDescriptor(base, property); if (desc.get) { return desc.get.call(receiver); } return desc.value; }; } return _get(target, property, receiver || target); }
+
+function _superPropBase(object, property) { while (!Object.prototype.hasOwnProperty.call(object, property)) { object = _getPrototypeOf(object); if (object === null) break; } return object; }
+
+function _getPrototypeOf(o) { _getPrototypeOf = Object.setPrototypeOf ? Object.getPrototypeOf : function _getPrototypeOf(o) { return o.__proto__ || Object.getPrototypeOf(o); }; return _getPrototypeOf(o); }
+
+function _inherits(subClass, superClass) { if (typeof superClass !== "function" && superClass !== null) { throw new TypeError("Super expression must either be null or a function"); } subClass.prototype = Object.create(superClass && superClass.prototype, { constructor: { value: subClass, writable: true, configurable: true } }); if (superClass) _setPrototypeOf(subClass, superClass); }
+
+function _setPrototypeOf(o, p) { _setPrototypeOf = Object.setPrototypeOf || function _setPrototypeOf(o, p) { o.__proto__ = p; return o; }; return _setPrototypeOf(o, p); }
 
 function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }
 
-var AnnotationFactory = function () {
+function _defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if ("value" in descriptor) descriptor.writable = true; Object.defineProperty(target, descriptor.key, descriptor); } }
+
+function _createClass(Constructor, protoProps, staticProps) { if (protoProps) _defineProperties(Constructor.prototype, protoProps); if (staticProps) _defineProperties(Constructor, staticProps); return Constructor; }
+
+var AnnotationFactory =
+/*#__PURE__*/
+function () {
   function AnnotationFactory() {
     _classCallCheck(this, AnnotationFactory);
   }
 
   _createClass(AnnotationFactory, null, [{
-    key: 'create',
+    key: "create",
     value: function create(xref, ref, pdfManager, idFactory) {
       return pdfManager.ensure(this, '_create', [xref, ref, pdfManager, idFactory]);
     }
   }, {
-    key: '_create',
+    key: "_create",
     value: function _create(xref, ref, pdfManager, idFactory) {
       var dict = xref.fetchIfRef(ref);
+
       if (!(0, _primitives.isDict)(dict)) {
         return;
       }
+
       var id = (0, _primitives.isRef)(ref) ? ref.toString() : 'annot_' + idFactory.createObjId();
       var subtype = dict.get('Subtype');
       subtype = (0, _primitives.isName)(subtype) ? subtype.name : null;
@@ -76,59 +92,81 @@ var AnnotationFactory = function () {
         id: id,
         pdfManager: pdfManager
       };
+
       switch (subtype) {
         case 'Link':
           return new LinkAnnotation(parameters);
+
         case 'Text':
           return new TextAnnotation(parameters);
+
         case 'Widget':
           var fieldType = (0, _util.getInheritableProperty)({
             dict: dict,
             key: 'FT'
           });
           fieldType = (0, _primitives.isName)(fieldType) ? fieldType.name : null;
+
           switch (fieldType) {
             case 'Tx':
               return new TextWidgetAnnotation(parameters);
+
             case 'Btn':
               return new ButtonWidgetAnnotation(parameters);
+
             case 'Ch':
               return new ChoiceWidgetAnnotation(parameters);
           }
+
           (0, _util.warn)('Unimplemented widget field type "' + fieldType + '", ' + 'falling back to base field type.');
           return new WidgetAnnotation(parameters);
+
         case 'Popup':
           return new PopupAnnotation(parameters);
+
         case 'Line':
           return new LineAnnotation(parameters);
+
         case 'Square':
           return new SquareAnnotation(parameters);
+
         case 'Circle':
           return new CircleAnnotation(parameters);
+
         case 'PolyLine':
           return new PolylineAnnotation(parameters);
+
         case 'Polygon':
           return new PolygonAnnotation(parameters);
+
         case 'Ink':
           return new InkAnnotation(parameters);
+
         case 'Highlight':
           return new HighlightAnnotation(parameters);
+
         case 'Underline':
           return new UnderlineAnnotation(parameters);
+
         case 'Squiggly':
           return new SquigglyAnnotation(parameters);
+
         case 'StrikeOut':
           return new StrikeOutAnnotation(parameters);
+
         case 'Stamp':
           return new StampAnnotation(parameters);
+
         case 'FileAttachment':
           return new FileAttachmentAnnotation(parameters);
+
         default:
           if (!subtype) {
             (0, _util.warn)('Annotation is missing the required /Subtype.');
           } else {
             (0, _util.warn)('Unimplemented annotation type "' + subtype + '", ' + 'falling back to base annotation.');
           }
+
           return new Annotation(parameters);
       }
     }
@@ -137,21 +175,28 @@ var AnnotationFactory = function () {
   return AnnotationFactory;
 }();
 
+exports.AnnotationFactory = AnnotationFactory;
+
 function getTransformMatrix(rect, bbox, matrix) {
   var bounds = _util.Util.getAxialAlignedBoundingBox(bbox, matrix);
+
   var minX = bounds[0];
   var minY = bounds[1];
   var maxX = bounds[2];
   var maxY = bounds[3];
+
   if (minX === maxX || minY === maxY) {
     return [1, 0, 0, 1, rect[0], rect[1]];
   }
+
   var xRatio = (rect[2] - rect[0]) / (maxX - minX);
   var yRatio = (rect[3] - rect[1]) / (maxY - minY);
   return [xRatio, 0, 0, yRatio, rect[0] - minX * xRatio, rect[1] - minY * yRatio];
 }
 
-var Annotation = function () {
+var Annotation =
+/*#__PURE__*/
+function () {
   function Annotation(params) {
     _classCallCheck(this, Annotation);
 
@@ -173,32 +218,32 @@ var Annotation = function () {
   }
 
   _createClass(Annotation, [{
-    key: '_hasFlag',
+    key: "_hasFlag",
     value: function _hasFlag(flags, flag) {
       return !!(flags & flag);
     }
   }, {
-    key: '_isViewable',
+    key: "_isViewable",
     value: function _isViewable(flags) {
       return !this._hasFlag(flags, _util.AnnotationFlag.INVISIBLE) && !this._hasFlag(flags, _util.AnnotationFlag.HIDDEN) && !this._hasFlag(flags, _util.AnnotationFlag.NOVIEW);
     }
   }, {
-    key: '_isPrintable',
+    key: "_isPrintable",
     value: function _isPrintable(flags) {
       return this._hasFlag(flags, _util.AnnotationFlag.PRINT) && !this._hasFlag(flags, _util.AnnotationFlag.INVISIBLE) && !this._hasFlag(flags, _util.AnnotationFlag.HIDDEN);
     }
   }, {
-    key: 'setFlags',
+    key: "setFlags",
     value: function setFlags(flags) {
       this.flags = Number.isInteger(flags) && flags > 0 ? flags : 0;
     }
   }, {
-    key: 'hasFlag',
+    key: "hasFlag",
     value: function hasFlag(flag) {
       return this._hasFlag(this.flags, flag);
     }
   }, {
-    key: 'setRectangle',
+    key: "setRectangle",
     value: function setRectangle(rectangle) {
       if (Array.isArray(rectangle) && rectangle.length === 4) {
         this.rectangle = _util.Util.normalizeRect(rectangle);
@@ -207,44 +252,56 @@ var Annotation = function () {
       }
     }
   }, {
-    key: 'setColor',
+    key: "setColor",
     value: function setColor(color) {
       var rgbColor = new Uint8ClampedArray(3);
+
       if (!Array.isArray(color)) {
         this.color = rgbColor;
         return;
       }
+
       switch (color.length) {
         case 0:
           this.color = null;
           break;
+
         case 1:
           _colorspace.ColorSpace.singletons.gray.getRgbItem(color, 0, rgbColor, 0);
+
           this.color = rgbColor;
           break;
+
         case 3:
           _colorspace.ColorSpace.singletons.rgb.getRgbItem(color, 0, rgbColor, 0);
+
           this.color = rgbColor;
           break;
+
         case 4:
           _colorspace.ColorSpace.singletons.cmyk.getRgbItem(color, 0, rgbColor, 0);
+
           this.color = rgbColor;
           break;
+
         default:
           this.color = rgbColor;
           break;
       }
     }
   }, {
-    key: 'setBorderStyle',
+    key: "setBorderStyle",
     value: function setBorderStyle(borderStyle) {
       this.borderStyle = new AnnotationBorderStyle();
+
       if (!(0, _primitives.isDict)(borderStyle)) {
         return;
       }
+
       if (borderStyle.has('BS')) {
         var dict = borderStyle.get('BS');
         var dictType = dict.get('Type');
+
         if (!dictType || (0, _primitives.isName)(dictType, 'Border')) {
           this.borderStyle.setWidth(dict.get('W'));
           this.borderStyle.setStyle(dict.get('S'));
@@ -252,10 +309,12 @@ var Annotation = function () {
         }
       } else if (borderStyle.has('Border')) {
         var array = borderStyle.getArray('Border');
+
         if (Array.isArray(array) && array.length >= 3) {
           this.borderStyle.setHorizontalCornerRadius(array[0]);
           this.borderStyle.setVerticalCornerRadius(array[1]);
           this.borderStyle.setWidth(array[2]);
+
           if (array.length === 4) {
             this.borderStyle.setDashArray(array[3]);
           }
@@ -265,44 +324,53 @@ var Annotation = function () {
       }
     }
   }, {
-    key: 'setAppearance',
+    key: "setAppearance",
     value: function setAppearance(dict) {
       this.appearance = null;
       var appearanceStates = dict.get('AP');
+
       if (!(0, _primitives.isDict)(appearanceStates)) {
         return;
       }
+
       var normalAppearanceState = appearanceStates.get('N');
+
       if ((0, _primitives.isStream)(normalAppearanceState)) {
         this.appearance = normalAppearanceState;
         return;
       }
+
       if (!(0, _primitives.isDict)(normalAppearanceState)) {
         return;
       }
+
       var as = dict.get('AS');
+
       if (!(0, _primitives.isName)(as) || !normalAppearanceState.has(as.name)) {
         return;
       }
+
       this.appearance = normalAppearanceState.get(as.name);
     }
   }, {
-    key: '_preparePopup',
+    key: "_preparePopup",
     value: function _preparePopup(dict) {
       if (!dict.has('C')) {
         this.data.color = null;
       }
+
       this.data.hasPopup = dict.has('Popup');
       this.data.title = (0, _util.stringToPDFString)(dict.get('T') || '');
       this.data.contents = (0, _util.stringToPDFString)(dict.get('Contents') || '');
     }
   }, {
-    key: 'loadResources',
+    key: "loadResources",
     value: function loadResources(keys) {
       return this.appearance.dict.getAsync('Resources').then(function (resources) {
         if (!resources) {
           return;
         }
+
         var objectLoader = new _obj.ObjectLoader(resources, keys, resources.xref);
         return objectLoader.load().then(function () {
           return resources;
@@ -310,13 +378,14 @@ var Annotation = function () {
       });
     }
   }, {
-    key: 'getOperatorList',
+    key: "getOperatorList",
     value: function getOperatorList(evaluator, task, renderForms) {
       var _this = this;
 
       if (!this.appearance) {
         return Promise.resolve(new _operator_list.OperatorList());
       }
+
       var data = this.data;
       var appearanceDict = this.appearance.dict;
       var resourcesPromise = this.loadResources(['ExtGState', 'ColorSpace', 'Pattern', 'Shading', 'XObject', 'Font']);
@@ -333,25 +402,29 @@ var Annotation = function () {
           operatorList: opList
         }).then(function () {
           opList.addOp(_util.OPS.endAnnotation, []);
+
           _this.appearance.reset();
+
           return opList;
         });
       });
     }
   }, {
-    key: 'viewable',
+    key: "viewable",
     get: function get() {
       if (this.flags === 0) {
         return true;
       }
+
       return this._isViewable(this.flags);
     }
   }, {
-    key: 'printable',
+    key: "printable",
     get: function get() {
       if (this.flags === 0) {
         return false;
       }
+
       return this._isPrintable(this.flags);
     }
   }]);
@@ -359,7 +432,11 @@ var Annotation = function () {
   return Annotation;
 }();
 
-var AnnotationBorderStyle = function () {
+exports.Annotation = Annotation;
+
+var AnnotationBorderStyle =
+/*#__PURE__*/
+function () {
   function AnnotationBorderStyle() {
     _classCallCheck(this, AnnotationBorderStyle);
 
@@ -371,47 +448,60 @@ var AnnotationBorderStyle = function () {
   }
 
   _createClass(AnnotationBorderStyle, [{
-    key: 'setWidth',
+    key: "setWidth",
     value: function setWidth(width) {
+      if ((0, _primitives.isName)(width)) {
+        this.width = 0;
+        return;
+      }
+
       if (Number.isInteger(width)) {
         this.width = width;
       }
     }
   }, {
-    key: 'setStyle',
+    key: "setStyle",
     value: function setStyle(style) {
-      if (!style) {
+      if (!(0, _primitives.isName)(style)) {
         return;
       }
+
       switch (style.name) {
         case 'S':
           this.style = _util.AnnotationBorderStyleType.SOLID;
           break;
+
         case 'D':
           this.style = _util.AnnotationBorderStyleType.DASHED;
           break;
+
         case 'B':
           this.style = _util.AnnotationBorderStyleType.BEVELED;
           break;
+
         case 'I':
           this.style = _util.AnnotationBorderStyleType.INSET;
           break;
+
         case 'U':
           this.style = _util.AnnotationBorderStyleType.UNDERLINE;
           break;
+
         default:
           break;
       }
     }
   }, {
-    key: 'setDashArray',
+    key: "setDashArray",
     value: function setDashArray(dashArray) {
       if (Array.isArray(dashArray) && dashArray.length > 0) {
         var isValid = true;
         var allZeros = true;
+
         for (var i = 0, len = dashArray.length; i < len; i++) {
           var element = dashArray[i];
           var validNumber = +element >= 0;
+
           if (!validNumber) {
             isValid = false;
             break;
@@ -419,6 +509,7 @@ var AnnotationBorderStyle = function () {
             allZeros = false;
           }
         }
+
         if (isValid && !allZeros) {
           this.dashArray = dashArray;
         } else {
@@ -429,14 +520,14 @@ var AnnotationBorderStyle = function () {
       }
     }
   }, {
-    key: 'setHorizontalCornerRadius',
+    key: "setHorizontalCornerRadius",
     value: function setHorizontalCornerRadius(radius) {
       if (Number.isInteger(radius)) {
         this.horizontalCornerRadius = radius;
       }
     }
   }, {
-    key: 'setVerticalCornerRadius',
+    key: "setVerticalCornerRadius",
     value: function setVerticalCornerRadius(radius) {
       if (Number.isInteger(radius)) {
         this.verticalCornerRadius = radius;
@@ -447,14 +538,19 @@ var AnnotationBorderStyle = function () {
   return AnnotationBorderStyle;
 }();
 
-var WidgetAnnotation = function (_Annotation) {
+exports.AnnotationBorderStyle = AnnotationBorderStyle;
+
+var WidgetAnnotation =
+/*#__PURE__*/
+function (_Annotation) {
   _inherits(WidgetAnnotation, _Annotation);
 
   function WidgetAnnotation(params) {
-    _classCallCheck(this, WidgetAnnotation);
+    var _this2;
 
-    var _this2 = _possibleConstructorReturn(this, (WidgetAnnotation.__proto__ || Object.getPrototypeOf(WidgetAnnotation)).call(this, params));
+    _classCallCheck(this, WidgetAnnotation);
 
+    _this2 = _possibleConstructorReturn(this, _getPrototypeOf(WidgetAnnotation).call(this, params));
     var dict = params.dict;
     var data = _this2.data;
     data.annotationType = _util.AnnotationType.WIDGET;
@@ -482,85 +578,107 @@ var WidgetAnnotation = function (_Annotation) {
       dict: dict,
       key: 'Ff'
     });
+
     if (!Number.isInteger(data.fieldFlags) || data.fieldFlags < 0) {
       data.fieldFlags = 0;
     }
+
     data.readOnly = _this2.hasFieldFlag(_util.AnnotationFieldFlag.READONLY);
+
     if (data.fieldType === 'Sig') {
+      data.fieldValue = null;
+
       _this2.setFlags(_util.AnnotationFlag.HIDDEN);
     }
+
     return _this2;
   }
 
   _createClass(WidgetAnnotation, [{
-    key: '_constructFieldName',
+    key: "_constructFieldName",
     value: function _constructFieldName(dict) {
       if (!dict.has('T') && !dict.has('Parent')) {
         (0, _util.warn)('Unknown field name, falling back to empty field name.');
         return '';
       }
+
       if (!dict.has('Parent')) {
         return (0, _util.stringToPDFString)(dict.get('T'));
       }
+
       var fieldName = [];
+
       if (dict.has('T')) {
         fieldName.unshift((0, _util.stringToPDFString)(dict.get('T')));
       }
+
       var loopDict = dict;
+
       while (loopDict.has('Parent')) {
         loopDict = loopDict.get('Parent');
+
         if (!(0, _primitives.isDict)(loopDict)) {
           break;
         }
+
         if (loopDict.has('T')) {
           fieldName.unshift((0, _util.stringToPDFString)(loopDict.get('T')));
         }
       }
+
       return fieldName.join('.');
     }
   }, {
-    key: 'hasFieldFlag',
+    key: "hasFieldFlag",
     value: function hasFieldFlag(flag) {
       return !!(this.data.fieldFlags & flag);
     }
   }, {
-    key: 'getOperatorList',
+    key: "getOperatorList",
     value: function getOperatorList(evaluator, task, renderForms) {
       if (renderForms) {
         return Promise.resolve(new _operator_list.OperatorList());
       }
-      return _get(WidgetAnnotation.prototype.__proto__ || Object.getPrototypeOf(WidgetAnnotation.prototype), 'getOperatorList', this).call(this, evaluator, task, renderForms);
+
+      return _get(_getPrototypeOf(WidgetAnnotation.prototype), "getOperatorList", this).call(this, evaluator, task, renderForms);
     }
   }]);
 
   return WidgetAnnotation;
 }(Annotation);
 
-var TextWidgetAnnotation = function (_WidgetAnnotation) {
+var TextWidgetAnnotation =
+/*#__PURE__*/
+function (_WidgetAnnotation) {
   _inherits(TextWidgetAnnotation, _WidgetAnnotation);
 
   function TextWidgetAnnotation(params) {
-    _classCallCheck(this, TextWidgetAnnotation);
+    var _this3;
 
-    var _this3 = _possibleConstructorReturn(this, (TextWidgetAnnotation.__proto__ || Object.getPrototypeOf(TextWidgetAnnotation)).call(this, params));
+    _classCallCheck(this, TextWidgetAnnotation);
 
+    _this3 = _possibleConstructorReturn(this, _getPrototypeOf(TextWidgetAnnotation).call(this, params));
     var dict = params.dict;
     _this3.data.fieldValue = (0, _util.stringToPDFString)(_this3.data.fieldValue || '');
     var alignment = (0, _util.getInheritableProperty)({
       dict: dict,
       key: 'Q'
     });
+
     if (!Number.isInteger(alignment) || alignment < 0 || alignment > 2) {
       alignment = null;
     }
+
     _this3.data.textAlignment = alignment;
     var maximumLength = (0, _util.getInheritableProperty)({
       dict: dict,
       key: 'MaxLen'
     });
+
     if (!Number.isInteger(maximumLength) || maximumLength < 0) {
       maximumLength = null;
     }
+
     _this3.data.maxLen = maximumLength;
     _this3.data.multiLine = _this3.hasFieldFlag(_util.AnnotationFieldFlag.MULTILINE);
     _this3.data.comb = _this3.hasFieldFlag(_util.AnnotationFieldFlag.COMB) && !_this3.hasFieldFlag(_util.AnnotationFieldFlag.MULTILINE) && !_this3.hasFieldFlag(_util.AnnotationFieldFlag.PASSWORD) && !_this3.hasFieldFlag(_util.AnnotationFieldFlag.FILESELECT) && _this3.data.maxLen !== null;
@@ -568,15 +686,18 @@ var TextWidgetAnnotation = function (_WidgetAnnotation) {
   }
 
   _createClass(TextWidgetAnnotation, [{
-    key: 'getOperatorList',
+    key: "getOperatorList",
     value: function getOperatorList(evaluator, task, renderForms) {
       if (renderForms || this.appearance) {
-        return _get(TextWidgetAnnotation.prototype.__proto__ || Object.getPrototypeOf(TextWidgetAnnotation.prototype), 'getOperatorList', this).call(this, evaluator, task, renderForms);
+        return _get(_getPrototypeOf(TextWidgetAnnotation.prototype), "getOperatorList", this).call(this, evaluator, task, renderForms);
       }
+
       var operatorList = new _operator_list.OperatorList();
+
       if (!this.data.defaultAppearance) {
         return Promise.resolve(operatorList);
       }
+
       var stream = new _stream.Stream((0, _util.stringToBytes)(this.data.defaultAppearance));
       return evaluator.getOperatorList({
         stream: stream,
@@ -592,17 +713,21 @@ var TextWidgetAnnotation = function (_WidgetAnnotation) {
   return TextWidgetAnnotation;
 }(WidgetAnnotation);
 
-var ButtonWidgetAnnotation = function (_WidgetAnnotation2) {
+var ButtonWidgetAnnotation =
+/*#__PURE__*/
+function (_WidgetAnnotation2) {
   _inherits(ButtonWidgetAnnotation, _WidgetAnnotation2);
 
   function ButtonWidgetAnnotation(params) {
-    _classCallCheck(this, ButtonWidgetAnnotation);
+    var _this4;
 
-    var _this4 = _possibleConstructorReturn(this, (ButtonWidgetAnnotation.__proto__ || Object.getPrototypeOf(ButtonWidgetAnnotation)).call(this, params));
+    _classCallCheck(this, ButtonWidgetAnnotation);
 
+    _this4 = _possibleConstructorReturn(this, _getPrototypeOf(ButtonWidgetAnnotation).call(this, params));
     _this4.data.checkBox = !_this4.hasFieldFlag(_util.AnnotationFieldFlag.RADIO) && !_this4.hasFieldFlag(_util.AnnotationFieldFlag.PUSHBUTTON);
     _this4.data.radioButton = _this4.hasFieldFlag(_util.AnnotationFieldFlag.RADIO) && !_this4.hasFieldFlag(_util.AnnotationFieldFlag.PUSHBUTTON);
     _this4.data.pushButton = _this4.hasFieldFlag(_util.AnnotationFieldFlag.PUSHBUTTON);
+
     if (_this4.data.checkBox) {
       _this4._processCheckBox(params);
     } else if (_this4.data.radioButton) {
@@ -612,50 +737,66 @@ var ButtonWidgetAnnotation = function (_WidgetAnnotation2) {
     } else {
       (0, _util.warn)('Invalid field flags for button widget annotation');
     }
+
     return _this4;
   }
 
   _createClass(ButtonWidgetAnnotation, [{
-    key: '_processCheckBox',
+    key: "_processCheckBox",
     value: function _processCheckBox(params) {
       if ((0, _primitives.isName)(this.data.fieldValue)) {
         this.data.fieldValue = this.data.fieldValue.name;
       }
+
       var customAppearance = params.dict.get('AP');
+
       if (!(0, _primitives.isDict)(customAppearance)) {
         return;
       }
+
       var exportValueOptionsDict = customAppearance.get('D');
+
       if (!(0, _primitives.isDict)(exportValueOptionsDict)) {
         return;
       }
+
       var exportValues = exportValueOptionsDict.getKeys();
       var hasCorrectOptionCount = exportValues.length === 2;
+
       if (!hasCorrectOptionCount) {
         return;
       }
+
       this.data.exportValue = exportValues[0] === 'Off' ? exportValues[1] : exportValues[0];
     }
   }, {
-    key: '_processRadioButton',
+    key: "_processRadioButton",
     value: function _processRadioButton(params) {
       this.data.fieldValue = this.data.buttonValue = null;
       var fieldParent = params.dict.get('Parent');
+
       if ((0, _primitives.isDict)(fieldParent) && fieldParent.has('V')) {
         var fieldParentValue = fieldParent.get('V');
+
         if ((0, _primitives.isName)(fieldParentValue)) {
           this.data.fieldValue = fieldParentValue.name;
         }
       }
+
       var appearanceStates = params.dict.get('AP');
+
       if (!(0, _primitives.isDict)(appearanceStates)) {
         return;
       }
+
       var normalAppearanceState = appearanceStates.get('N');
+
       if (!(0, _primitives.isDict)(normalAppearanceState)) {
         return;
       }
+
       var keys = normalAppearanceState.getKeys();
+
       for (var i = 0, ii = keys.length; i < ii; i++) {
         if (keys[i] !== 'Off') {
           this.data.buttonValue = keys[i];
@@ -664,12 +805,13 @@ var ButtonWidgetAnnotation = function (_WidgetAnnotation2) {
       }
     }
   }, {
-    key: '_processPushButton',
+    key: "_processPushButton",
     value: function _processPushButton(params) {
       if (!params.dict.has('A')) {
         (0, _util.warn)('Push buttons without action dictionaries are not supported');
         return;
       }
+
       _obj.Catalog.parseDestDictionary({
         destDict: params.dict,
         resultObj: this.data,
@@ -681,21 +823,26 @@ var ButtonWidgetAnnotation = function (_WidgetAnnotation2) {
   return ButtonWidgetAnnotation;
 }(WidgetAnnotation);
 
-var ChoiceWidgetAnnotation = function (_WidgetAnnotation3) {
+var ChoiceWidgetAnnotation =
+/*#__PURE__*/
+function (_WidgetAnnotation3) {
   _inherits(ChoiceWidgetAnnotation, _WidgetAnnotation3);
 
   function ChoiceWidgetAnnotation(params) {
-    _classCallCheck(this, ChoiceWidgetAnnotation);
+    var _this5;
 
-    var _this5 = _possibleConstructorReturn(this, (ChoiceWidgetAnnotation.__proto__ || Object.getPrototypeOf(ChoiceWidgetAnnotation)).call(this, params));
+    _classCallCheck(this, ChoiceWidgetAnnotation);
 
+    _this5 = _possibleConstructorReturn(this, _getPrototypeOf(ChoiceWidgetAnnotation).call(this, params));
     _this5.data.options = [];
     var options = (0, _util.getInheritableProperty)({
       dict: params.dict,
       key: 'Opt'
     });
+
     if (Array.isArray(options)) {
       var xref = params.xref;
+
       for (var i = 0, ii = options.length; i < ii; i++) {
         var option = xref.fetchIfRef(options[i]);
         var isOptionArray = Array.isArray(option);
@@ -705,9 +852,11 @@ var ChoiceWidgetAnnotation = function (_WidgetAnnotation3) {
         };
       }
     }
+
     if (!Array.isArray(_this5.data.fieldValue)) {
       _this5.data.fieldValue = [_this5.data.fieldValue];
     }
+
     _this5.data.combo = _this5.hasFieldFlag(_util.AnnotationFieldFlag.COMBO);
     _this5.data.multiSelect = _this5.hasFieldFlag(_util.AnnotationFieldFlag.MULTISELECT);
     return _this5;
@@ -716,17 +865,20 @@ var ChoiceWidgetAnnotation = function (_WidgetAnnotation3) {
   return ChoiceWidgetAnnotation;
 }(WidgetAnnotation);
 
-var TextAnnotation = function (_Annotation2) {
+var TextAnnotation =
+/*#__PURE__*/
+function (_Annotation2) {
   _inherits(TextAnnotation, _Annotation2);
 
   function TextAnnotation(parameters) {
+    var _this6;
+
     _classCallCheck(this, TextAnnotation);
 
     var DEFAULT_ICON_SIZE = 22;
-
-    var _this6 = _possibleConstructorReturn(this, (TextAnnotation.__proto__ || Object.getPrototypeOf(TextAnnotation)).call(this, parameters));
-
+    _this6 = _possibleConstructorReturn(this, _getPrototypeOf(TextAnnotation).call(this, parameters));
     _this6.data.annotationType = _util.AnnotationType.TEXT;
+
     if (_this6.data.hasAppearance) {
       _this6.data.name = 'NoIcon';
     } else {
@@ -734,154 +886,195 @@ var TextAnnotation = function (_Annotation2) {
       _this6.data.rect[2] = _this6.data.rect[0] + DEFAULT_ICON_SIZE;
       _this6.data.name = parameters.dict.has('Name') ? parameters.dict.get('Name').name : 'Note';
     }
+
     _this6._preparePopup(parameters.dict);
+
     return _this6;
   }
 
   return TextAnnotation;
 }(Annotation);
 
-var LinkAnnotation = function (_Annotation3) {
+var LinkAnnotation =
+/*#__PURE__*/
+function (_Annotation3) {
   _inherits(LinkAnnotation, _Annotation3);
 
   function LinkAnnotation(params) {
-    _classCallCheck(this, LinkAnnotation);
+    var _this7;
 
-    var _this7 = _possibleConstructorReturn(this, (LinkAnnotation.__proto__ || Object.getPrototypeOf(LinkAnnotation)).call(this, params));
+    _classCallCheck(this, LinkAnnotation);
 
+    _this7 = _possibleConstructorReturn(this, _getPrototypeOf(LinkAnnotation).call(this, params));
     _this7.data.annotationType = _util.AnnotationType.LINK;
+
     _obj.Catalog.parseDestDictionary({
       destDict: params.dict,
       resultObj: _this7.data,
       docBaseUrl: params.pdfManager.docBaseUrl
     });
+
     return _this7;
   }
 
   return LinkAnnotation;
 }(Annotation);
 
-var PopupAnnotation = function (_Annotation4) {
+var PopupAnnotation =
+/*#__PURE__*/
+function (_Annotation4) {
   _inherits(PopupAnnotation, _Annotation4);
 
   function PopupAnnotation(parameters) {
-    _classCallCheck(this, PopupAnnotation);
+    var _this8;
 
-    var _this8 = _possibleConstructorReturn(this, (PopupAnnotation.__proto__ || Object.getPrototypeOf(PopupAnnotation)).call(this, parameters));
+    _classCallCheck(this, PopupAnnotation);
 
+    _this8 = _possibleConstructorReturn(this, _getPrototypeOf(PopupAnnotation).call(this, parameters));
     _this8.data.annotationType = _util.AnnotationType.POPUP;
     var dict = parameters.dict;
     var parentItem = dict.get('Parent');
+
     if (!parentItem) {
       (0, _util.warn)('Popup annotation has a missing or invalid parent annotation.');
       return _possibleConstructorReturn(_this8);
     }
+
     var parentSubtype = parentItem.get('Subtype');
     _this8.data.parentType = (0, _primitives.isName)(parentSubtype) ? parentSubtype.name : null;
     _this8.data.parentId = dict.getRaw('Parent').toString();
     _this8.data.title = (0, _util.stringToPDFString)(parentItem.get('T') || '');
     _this8.data.contents = (0, _util.stringToPDFString)(parentItem.get('Contents') || '');
+
     if (!parentItem.has('C')) {
       _this8.data.color = null;
     } else {
       _this8.setColor(parentItem.getArray('C'));
+
       _this8.data.color = _this8.color;
     }
+
     if (!_this8.viewable) {
       var parentFlags = parentItem.get('F');
+
       if (_this8._isViewable(parentFlags)) {
         _this8.setFlags(parentFlags);
       }
     }
+
     return _this8;
   }
 
   return PopupAnnotation;
 }(Annotation);
 
-var LineAnnotation = function (_Annotation5) {
+var LineAnnotation =
+/*#__PURE__*/
+function (_Annotation5) {
   _inherits(LineAnnotation, _Annotation5);
 
   function LineAnnotation(parameters) {
-    _classCallCheck(this, LineAnnotation);
+    var _this9;
 
-    var _this9 = _possibleConstructorReturn(this, (LineAnnotation.__proto__ || Object.getPrototypeOf(LineAnnotation)).call(this, parameters));
+    _classCallCheck(this, LineAnnotation);
 
+    _this9 = _possibleConstructorReturn(this, _getPrototypeOf(LineAnnotation).call(this, parameters));
     _this9.data.annotationType = _util.AnnotationType.LINE;
     var dict = parameters.dict;
     _this9.data.lineCoordinates = _util.Util.normalizeRect(dict.getArray('L'));
+
     _this9._preparePopup(dict);
+
     return _this9;
   }
 
   return LineAnnotation;
 }(Annotation);
 
-var SquareAnnotation = function (_Annotation6) {
+var SquareAnnotation =
+/*#__PURE__*/
+function (_Annotation6) {
   _inherits(SquareAnnotation, _Annotation6);
 
   function SquareAnnotation(parameters) {
-    _classCallCheck(this, SquareAnnotation);
+    var _this10;
 
-    var _this10 = _possibleConstructorReturn(this, (SquareAnnotation.__proto__ || Object.getPrototypeOf(SquareAnnotation)).call(this, parameters));
+    _classCallCheck(this, SquareAnnotation);
 
+    _this10 = _possibleConstructorReturn(this, _getPrototypeOf(SquareAnnotation).call(this, parameters));
     _this10.data.annotationType = _util.AnnotationType.SQUARE;
+
     _this10._preparePopup(parameters.dict);
+
     return _this10;
   }
 
   return SquareAnnotation;
 }(Annotation);
 
-var CircleAnnotation = function (_Annotation7) {
+var CircleAnnotation =
+/*#__PURE__*/
+function (_Annotation7) {
   _inherits(CircleAnnotation, _Annotation7);
 
   function CircleAnnotation(parameters) {
-    _classCallCheck(this, CircleAnnotation);
+    var _this11;
 
-    var _this11 = _possibleConstructorReturn(this, (CircleAnnotation.__proto__ || Object.getPrototypeOf(CircleAnnotation)).call(this, parameters));
+    _classCallCheck(this, CircleAnnotation);
 
+    _this11 = _possibleConstructorReturn(this, _getPrototypeOf(CircleAnnotation).call(this, parameters));
     _this11.data.annotationType = _util.AnnotationType.CIRCLE;
+
     _this11._preparePopup(parameters.dict);
+
     return _this11;
   }
 
   return CircleAnnotation;
 }(Annotation);
 
-var PolylineAnnotation = function (_Annotation8) {
+var PolylineAnnotation =
+/*#__PURE__*/
+function (_Annotation8) {
   _inherits(PolylineAnnotation, _Annotation8);
 
   function PolylineAnnotation(parameters) {
-    _classCallCheck(this, PolylineAnnotation);
+    var _this12;
 
-    var _this12 = _possibleConstructorReturn(this, (PolylineAnnotation.__proto__ || Object.getPrototypeOf(PolylineAnnotation)).call(this, parameters));
+    _classCallCheck(this, PolylineAnnotation);
 
+    _this12 = _possibleConstructorReturn(this, _getPrototypeOf(PolylineAnnotation).call(this, parameters));
     _this12.data.annotationType = _util.AnnotationType.POLYLINE;
     var dict = parameters.dict;
     var rawVertices = dict.getArray('Vertices');
     _this12.data.vertices = [];
+
     for (var i = 0, ii = rawVertices.length; i < ii; i += 2) {
       _this12.data.vertices.push({
         x: rawVertices[i],
         y: rawVertices[i + 1]
       });
     }
+
     _this12._preparePopup(dict);
+
     return _this12;
   }
 
   return PolylineAnnotation;
 }(Annotation);
 
-var PolygonAnnotation = function (_PolylineAnnotation) {
+var PolygonAnnotation =
+/*#__PURE__*/
+function (_PolylineAnnotation) {
   _inherits(PolygonAnnotation, _PolylineAnnotation);
 
   function PolygonAnnotation(parameters) {
-    _classCallCheck(this, PolygonAnnotation);
+    var _this13;
 
-    var _this13 = _possibleConstructorReturn(this, (PolygonAnnotation.__proto__ || Object.getPrototypeOf(PolygonAnnotation)).call(this, parameters));
+    _classCallCheck(this, PolygonAnnotation);
 
+    _this13 = _possibleConstructorReturn(this, _getPrototypeOf(PolygonAnnotation).call(this, parameters));
     _this13.data.annotationType = _util.AnnotationType.POLYGON;
     return _this13;
   }
@@ -889,21 +1082,26 @@ var PolygonAnnotation = function (_PolylineAnnotation) {
   return PolygonAnnotation;
 }(PolylineAnnotation);
 
-var InkAnnotation = function (_Annotation9) {
+var InkAnnotation =
+/*#__PURE__*/
+function (_Annotation9) {
   _inherits(InkAnnotation, _Annotation9);
 
   function InkAnnotation(parameters) {
-    _classCallCheck(this, InkAnnotation);
+    var _this14;
 
-    var _this14 = _possibleConstructorReturn(this, (InkAnnotation.__proto__ || Object.getPrototypeOf(InkAnnotation)).call(this, parameters));
+    _classCallCheck(this, InkAnnotation);
 
+    _this14 = _possibleConstructorReturn(this, _getPrototypeOf(InkAnnotation).call(this, parameters));
     _this14.data.annotationType = _util.AnnotationType.INK;
     var dict = parameters.dict;
     var xref = parameters.xref;
     var originalInkLists = dict.getArray('InkList');
     _this14.data.inkLists = [];
+
     for (var i = 0, ii = originalInkLists.length; i < ii; ++i) {
       _this14.data.inkLists.push([]);
+
       for (var j = 0, jj = originalInkLists[i].length; j < jj; j += 2) {
         _this14.data.inkLists[i].push({
           x: xref.fetchIfRef(originalInkLists[i][j]),
@@ -911,111 +1109,139 @@ var InkAnnotation = function (_Annotation9) {
         });
       }
     }
+
     _this14._preparePopup(dict);
+
     return _this14;
   }
 
   return InkAnnotation;
 }(Annotation);
 
-var HighlightAnnotation = function (_Annotation10) {
+var HighlightAnnotation =
+/*#__PURE__*/
+function (_Annotation10) {
   _inherits(HighlightAnnotation, _Annotation10);
 
   function HighlightAnnotation(parameters) {
-    _classCallCheck(this, HighlightAnnotation);
+    var _this15;
 
-    var _this15 = _possibleConstructorReturn(this, (HighlightAnnotation.__proto__ || Object.getPrototypeOf(HighlightAnnotation)).call(this, parameters));
+    _classCallCheck(this, HighlightAnnotation);
 
+    _this15 = _possibleConstructorReturn(this, _getPrototypeOf(HighlightAnnotation).call(this, parameters));
     _this15.data.annotationType = _util.AnnotationType.HIGHLIGHT;
+
     _this15._preparePopup(parameters.dict);
+
     return _this15;
   }
 
   return HighlightAnnotation;
 }(Annotation);
 
-var UnderlineAnnotation = function (_Annotation11) {
+var UnderlineAnnotation =
+/*#__PURE__*/
+function (_Annotation11) {
   _inherits(UnderlineAnnotation, _Annotation11);
 
   function UnderlineAnnotation(parameters) {
-    _classCallCheck(this, UnderlineAnnotation);
+    var _this16;
 
-    var _this16 = _possibleConstructorReturn(this, (UnderlineAnnotation.__proto__ || Object.getPrototypeOf(UnderlineAnnotation)).call(this, parameters));
+    _classCallCheck(this, UnderlineAnnotation);
 
+    _this16 = _possibleConstructorReturn(this, _getPrototypeOf(UnderlineAnnotation).call(this, parameters));
     _this16.data.annotationType = _util.AnnotationType.UNDERLINE;
+
     _this16._preparePopup(parameters.dict);
+
     return _this16;
   }
 
   return UnderlineAnnotation;
 }(Annotation);
 
-var SquigglyAnnotation = function (_Annotation12) {
+var SquigglyAnnotation =
+/*#__PURE__*/
+function (_Annotation12) {
   _inherits(SquigglyAnnotation, _Annotation12);
 
   function SquigglyAnnotation(parameters) {
-    _classCallCheck(this, SquigglyAnnotation);
+    var _this17;
 
-    var _this17 = _possibleConstructorReturn(this, (SquigglyAnnotation.__proto__ || Object.getPrototypeOf(SquigglyAnnotation)).call(this, parameters));
+    _classCallCheck(this, SquigglyAnnotation);
 
+    _this17 = _possibleConstructorReturn(this, _getPrototypeOf(SquigglyAnnotation).call(this, parameters));
     _this17.data.annotationType = _util.AnnotationType.SQUIGGLY;
+
     _this17._preparePopup(parameters.dict);
+
     return _this17;
   }
 
   return SquigglyAnnotation;
 }(Annotation);
 
-var StrikeOutAnnotation = function (_Annotation13) {
+var StrikeOutAnnotation =
+/*#__PURE__*/
+function (_Annotation13) {
   _inherits(StrikeOutAnnotation, _Annotation13);
 
   function StrikeOutAnnotation(parameters) {
-    _classCallCheck(this, StrikeOutAnnotation);
+    var _this18;
 
-    var _this18 = _possibleConstructorReturn(this, (StrikeOutAnnotation.__proto__ || Object.getPrototypeOf(StrikeOutAnnotation)).call(this, parameters));
+    _classCallCheck(this, StrikeOutAnnotation);
 
+    _this18 = _possibleConstructorReturn(this, _getPrototypeOf(StrikeOutAnnotation).call(this, parameters));
     _this18.data.annotationType = _util.AnnotationType.STRIKEOUT;
+
     _this18._preparePopup(parameters.dict);
+
     return _this18;
   }
 
   return StrikeOutAnnotation;
 }(Annotation);
 
-var StampAnnotation = function (_Annotation14) {
+var StampAnnotation =
+/*#__PURE__*/
+function (_Annotation14) {
   _inherits(StampAnnotation, _Annotation14);
 
   function StampAnnotation(parameters) {
-    _classCallCheck(this, StampAnnotation);
+    var _this19;
 
-    var _this19 = _possibleConstructorReturn(this, (StampAnnotation.__proto__ || Object.getPrototypeOf(StampAnnotation)).call(this, parameters));
+    _classCallCheck(this, StampAnnotation);
 
+    _this19 = _possibleConstructorReturn(this, _getPrototypeOf(StampAnnotation).call(this, parameters));
     _this19.data.annotationType = _util.AnnotationType.STAMP;
+
     _this19._preparePopup(parameters.dict);
+
     return _this19;
   }
 
   return StampAnnotation;
 }(Annotation);
 
-var FileAttachmentAnnotation = function (_Annotation15) {
+var FileAttachmentAnnotation =
+/*#__PURE__*/
+function (_Annotation15) {
   _inherits(FileAttachmentAnnotation, _Annotation15);
 
   function FileAttachmentAnnotation(parameters) {
-    _classCallCheck(this, FileAttachmentAnnotation);
+    var _this20;
 
-    var _this20 = _possibleConstructorReturn(this, (FileAttachmentAnnotation.__proto__ || Object.getPrototypeOf(FileAttachmentAnnotation)).call(this, parameters));
+    _classCallCheck(this, FileAttachmentAnnotation);
 
+    _this20 = _possibleConstructorReturn(this, _getPrototypeOf(FileAttachmentAnnotation).call(this, parameters));
     var file = new _obj.FileSpec(parameters.dict.get('FS'), parameters.xref);
     _this20.data.annotationType = _util.AnnotationType.FILEATTACHMENT;
     _this20.data.file = file.serializable;
+
     _this20._preparePopup(parameters.dict);
+
     return _this20;
   }
 
   return FileAttachmentAnnotation;
-}(Annotation);
-
-exports.Annotation = Annotation;
-exports.AnnotationBorderStyle = AnnotationBorderStyle;
-exports.AnnotationFactory = AnnotationFactory;
+}(Annotation);