pdfjs-dist 2.1.266 → 2.2.228

package/lib/core/annotation.js

@@ -2,7 +2,7 @@
  * @licstart The following is the entire license notice for the
  * Javascript code in this page
  *
- * Copyright 2018 Mozilla Foundation
+ * Copyright 2019 Mozilla Foundation
  *
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
@@ -24,7 +24,7 @@
 Object.defineProperty(exports, "__esModule", {
   value: true
 });
-exports.AnnotationFactory = exports.AnnotationBorderStyle = exports.Annotation = void 0;
+exports.MarkupAnnotation = exports.AnnotationFactory = exports.AnnotationBorderStyle = exports.Annotation = void 0;
 
 var _util = require("../shared/util");
 
@@ -34,20 +34,22 @@ var _primitives = require("./primitives");
 
 var _colorspace = require("./colorspace");
 
+var _core_utils = require("./core_utils");
+
 var _operator_list = require("./operator_list");
 
 var _stream = require("./stream");
 
+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 _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); }
 
 function _possibleConstructorReturn(self, call) { if (call && (_typeof(call) === "object" || typeof call === "function")) { return call; } return _assertThisInitialized(self); }
 
 function _assertThisInitialized(self) { if (self === void 0) { throw new ReferenceError("this hasn't been initialised - super() hasn't been called"); } return self; }
 
-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); }
@@ -78,16 +80,15 @@ function () {
       var dict = xref.fetchIfRef(ref);
 
       if (!(0, _primitives.isDict)(dict)) {
-        return;
+        return undefined;
       }
 
-      var id = (0, _primitives.isRef)(ref) ? ref.toString() : 'annot_' + idFactory.createObjId();
+      var id = (0, _primitives.isRef)(ref) ? ref.toString() : "annot_".concat(idFactory.createObjId());
       var subtype = dict.get('Subtype');
       subtype = (0, _primitives.isName)(subtype) ? subtype.name : null;
       var parameters = {
         xref: xref,
         dict: dict,
-        ref: (0, _primitives.isRef)(ref) ? ref : null,
         subtype: subtype,
         id: id,
         pdfManager: pdfManager
@@ -101,7 +102,7 @@ function () {
           return new TextAnnotation(parameters);
 
         case 'Widget':
-          var fieldType = (0, _util.getInheritableProperty)({
+          var fieldType = (0, _core_utils.getInheritableProperty)({
             dict: dict,
             key: 'FT'
           });
@@ -124,6 +125,9 @@ function () {
         case 'Popup':
           return new PopupAnnotation(parameters);
 
+        case 'FreeText':
+          return new FreeTextAnnotation(parameters);
+
         case 'Line':
           return new LineAnnotation(parameters);
 
@@ -139,6 +143,9 @@ function () {
         case 'Polygon':
           return new PolygonAnnotation(parameters);
 
+        case 'Caret':
+          return new CaretAnnotation(parameters);
+
         case 'Ink':
           return new InkAnnotation(parameters);
 
@@ -201,6 +208,8 @@ function () {
     _classCallCheck(this, Annotation);
 
     var dict = params.dict;
+    this.setContents(dict.get('Contents'));
+    this.setModificationDate(dict.get('M'));
     this.setFlags(dict.get('F'));
     this.setRectangle(dict.getArray('Rect'));
     this.setColor(dict.getArray('C'));
@@ -210,8 +219,10 @@ function () {
       annotationFlags: this.flags,
       borderStyle: this.borderStyle,
       color: this.color,
+      contents: this.contents,
       hasAppearance: !!this.appearance,
       id: params.id,
+      modificationDate: this.modificationDate,
       rect: this.rectangle,
       subtype: params.subtype
     };
@@ -232,6 +243,16 @@ function () {
     value: function _isPrintable(flags) {
       return this._hasFlag(flags, _util.AnnotationFlag.PRINT) && !this._hasFlag(flags, _util.AnnotationFlag.INVISIBLE) && !this._hasFlag(flags, _util.AnnotationFlag.HIDDEN);
     }
+  }, {
+    key: "setContents",
+    value: function setContents(contents) {
+      this.contents = (0, _util.stringToPDFString)(contents || '');
+    }
+  }, {
+    key: "setModificationDate",
+    value: function setModificationDate(modificationDate) {
+      this.modificationDate = (0, _util.isString)(modificationDate) ? modificationDate : null;
+    }
   }, {
     key: "setFlags",
     value: function setFlags(flags) {
@@ -303,7 +324,7 @@ function () {
         var dictType = dict.get('Type');
 
         if (!dictType || (0, _primitives.isName)(dictType, 'Border')) {
-          this.borderStyle.setWidth(dict.get('W'));
+          this.borderStyle.setWidth(dict.get('W'), this.rectangle);
           this.borderStyle.setStyle(dict.get('S'));
           this.borderStyle.setDashArray(dict.getArray('D'));
         }
@@ -313,7 +334,7 @@ function () {
         if (Array.isArray(array) && array.length >= 3) {
           this.borderStyle.setHorizontalCornerRadius(array[0]);
           this.borderStyle.setVerticalCornerRadius(array[1]);
-          this.borderStyle.setWidth(array[2]);
+          this.borderStyle.setWidth(array[2], this.rectangle);
 
           if (array.length === 4) {
             this.borderStyle.setDashArray(array[3]);
@@ -352,23 +373,12 @@ function () {
 
       this.appearance = normalAppearanceState.get(as.name);
     }
-  }, {
-    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",
     value: function loadResources(keys) {
       return this.appearance.dict.getAsync('Resources').then(function (resources) {
         if (!resources) {
-          return;
+          return undefined;
         }
 
         var objectLoader = new _obj.ObjectLoader(resources, keys, resources.xref);
@@ -450,12 +460,24 @@ function () {
   _createClass(AnnotationBorderStyle, [{
     key: "setWidth",
     value: function setWidth(width) {
+      var rect = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : [0, 0, 0, 0];
+
       if ((0, _primitives.isName)(width)) {
         this.width = 0;
         return;
       }
 
       if (Number.isInteger(width)) {
+        if (width > 0) {
+          var maxWidth = (rect[2] - rect[0]) / 2;
+          var maxHeight = (rect[3] - rect[1]) / 2;
+
+          if (maxWidth > 0 && maxHeight > 0 && (width > maxWidth || width > maxHeight)) {
+            (0, _util.warn)("AnnotationBorderStyle.setWidth - ignoring width: ".concat(width));
+            width = 1;
+          }
+        }
+
         this.width = width;
       }
     }
@@ -540,41 +562,78 @@ function () {
 
 exports.AnnotationBorderStyle = AnnotationBorderStyle;
 
-var WidgetAnnotation =
+var MarkupAnnotation =
 /*#__PURE__*/
 function (_Annotation) {
-  _inherits(WidgetAnnotation, _Annotation);
+  _inherits(MarkupAnnotation, _Annotation);
 
-  function WidgetAnnotation(params) {
+  function MarkupAnnotation(parameters) {
     var _this2;
 
+    _classCallCheck(this, MarkupAnnotation);
+
+    _this2 = _possibleConstructorReturn(this, _getPrototypeOf(MarkupAnnotation).call(this, parameters));
+    var dict = parameters.dict;
+
+    if (!dict.has('C')) {
+      _this2.data.color = null;
+    }
+
+    _this2.setCreationDate(dict.get('CreationDate'));
+
+    _this2.data.creationDate = _this2.creationDate;
+    _this2.data.hasPopup = dict.has('Popup');
+    _this2.data.title = (0, _util.stringToPDFString)(dict.get('T') || '');
+    return _this2;
+  }
+
+  _createClass(MarkupAnnotation, [{
+    key: "setCreationDate",
+    value: function setCreationDate(creationDate) {
+      this.creationDate = (0, _util.isString)(creationDate) ? creationDate : null;
+    }
+  }]);
+
+  return MarkupAnnotation;
+}(Annotation);
+
+exports.MarkupAnnotation = MarkupAnnotation;
+
+var WidgetAnnotation =
+/*#__PURE__*/
+function (_Annotation2) {
+  _inherits(WidgetAnnotation, _Annotation2);
+
+  function WidgetAnnotation(params) {
+    var _this3;
+
     _classCallCheck(this, WidgetAnnotation);
 
-    _this2 = _possibleConstructorReturn(this, _getPrototypeOf(WidgetAnnotation).call(this, params));
+    _this3 = _possibleConstructorReturn(this, _getPrototypeOf(WidgetAnnotation).call(this, params));
     var dict = params.dict;
-    var data = _this2.data;
+    var data = _this3.data;
     data.annotationType = _util.AnnotationType.WIDGET;
-    data.fieldName = _this2._constructFieldName(dict);
-    data.fieldValue = (0, _util.getInheritableProperty)({
+    data.fieldName = _this3._constructFieldName(dict);
+    data.fieldValue = (0, _core_utils.getInheritableProperty)({
       dict: dict,
       key: 'V',
       getArray: true
     });
     data.alternativeText = (0, _util.stringToPDFString)(dict.get('TU') || '');
-    data.defaultAppearance = (0, _util.getInheritableProperty)({
+    data.defaultAppearance = (0, _core_utils.getInheritableProperty)({
       dict: dict,
       key: 'DA'
     }) || '';
-    var fieldType = (0, _util.getInheritableProperty)({
+    var fieldType = (0, _core_utils.getInheritableProperty)({
       dict: dict,
       key: 'FT'
     });
     data.fieldType = (0, _primitives.isName)(fieldType) ? fieldType.name : null;
-    _this2.fieldResources = (0, _util.getInheritableProperty)({
+    _this3.fieldResources = (0, _core_utils.getInheritableProperty)({
       dict: dict,
       key: 'DR'
     }) || _primitives.Dict.empty;
-    data.fieldFlags = (0, _util.getInheritableProperty)({
+    data.fieldFlags = (0, _core_utils.getInheritableProperty)({
       dict: dict,
       key: 'Ff'
     });
@@ -583,15 +642,15 @@ function (_Annotation) {
       data.fieldFlags = 0;
     }
 
-    data.readOnly = _this2.hasFieldFlag(_util.AnnotationFieldFlag.READONLY);
+    data.readOnly = _this3.hasFieldFlag(_util.AnnotationFieldFlag.READONLY);
 
     if (data.fieldType === 'Sig') {
       data.fieldValue = null;
 
-      _this2.setFlags(_util.AnnotationFlag.HIDDEN);
+      _this3.setFlags(_util.AnnotationFlag.HIDDEN);
     }
 
-    return _this2;
+    return _this3;
   }
 
   _createClass(WidgetAnnotation, [{
@@ -653,14 +712,14 @@ function (_WidgetAnnotation) {
   _inherits(TextWidgetAnnotation, _WidgetAnnotation);
 
   function TextWidgetAnnotation(params) {
-    var _this3;
+    var _this4;
 
     _classCallCheck(this, TextWidgetAnnotation);
 
-    _this3 = _possibleConstructorReturn(this, _getPrototypeOf(TextWidgetAnnotation).call(this, params));
+    _this4 = _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)({
+    _this4.data.fieldValue = (0, _util.stringToPDFString)(_this4.data.fieldValue || '');
+    var alignment = (0, _core_utils.getInheritableProperty)({
       dict: dict,
       key: 'Q'
     });
@@ -669,8 +728,8 @@ function (_WidgetAnnotation) {
       alignment = null;
     }
 
-    _this3.data.textAlignment = alignment;
-    var maximumLength = (0, _util.getInheritableProperty)({
+    _this4.data.textAlignment = alignment;
+    var maximumLength = (0, _core_utils.getInheritableProperty)({
       dict: dict,
       key: 'MaxLen'
     });
@@ -679,10 +738,10 @@ function (_WidgetAnnotation) {
       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;
-    return _this3;
+    _this4.data.maxLen = maximumLength;
+    _this4.data.multiLine = _this4.hasFieldFlag(_util.AnnotationFieldFlag.MULTILINE);
+    _this4.data.comb = _this4.hasFieldFlag(_util.AnnotationFieldFlag.COMB) && !_this4.hasFieldFlag(_util.AnnotationFieldFlag.MULTILINE) && !_this4.hasFieldFlag(_util.AnnotationFieldFlag.PASSWORD) && !_this4.hasFieldFlag(_util.AnnotationFieldFlag.FILESELECT) && _this4.data.maxLen !== null;
+    return _this4;
   }
 
   _createClass(TextWidgetAnnotation, [{
@@ -719,26 +778,26 @@ function (_WidgetAnnotation2) {
   _inherits(ButtonWidgetAnnotation, _WidgetAnnotation2);
 
   function ButtonWidgetAnnotation(params) {
-    var _this4;
+    var _this5;
 
     _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) {
-      _this4._processRadioButton(params);
-    } else if (_this4.data.pushButton) {
-      _this4._processPushButton(params);
+    _this5 = _possibleConstructorReturn(this, _getPrototypeOf(ButtonWidgetAnnotation).call(this, params));
+    _this5.data.checkBox = !_this5.hasFieldFlag(_util.AnnotationFieldFlag.RADIO) && !_this5.hasFieldFlag(_util.AnnotationFieldFlag.PUSHBUTTON);
+    _this5.data.radioButton = _this5.hasFieldFlag(_util.AnnotationFieldFlag.RADIO) && !_this5.hasFieldFlag(_util.AnnotationFieldFlag.PUSHBUTTON);
+    _this5.data.pushButton = _this5.hasFieldFlag(_util.AnnotationFieldFlag.PUSHBUTTON);
+
+    if (_this5.data.checkBox) {
+      _this5._processCheckBox(params);
+    } else if (_this5.data.radioButton) {
+      _this5._processRadioButton(params);
+    } else if (_this5.data.pushButton) {
+      _this5._processPushButton(params);
     } else {
       (0, _util.warn)('Invalid field flags for button widget annotation');
     }
 
-    return _this4;
+    return _this5;
   }
 
   _createClass(ButtonWidgetAnnotation, [{
@@ -829,13 +888,13 @@ function (_WidgetAnnotation3) {
   _inherits(ChoiceWidgetAnnotation, _WidgetAnnotation3);
 
   function ChoiceWidgetAnnotation(params) {
-    var _this5;
+    var _this6;
 
     _classCallCheck(this, ChoiceWidgetAnnotation);
 
-    _this5 = _possibleConstructorReturn(this, _getPrototypeOf(ChoiceWidgetAnnotation).call(this, params));
-    _this5.data.options = [];
-    var options = (0, _util.getInheritableProperty)({
+    _this6 = _possibleConstructorReturn(this, _getPrototypeOf(ChoiceWidgetAnnotation).call(this, params));
+    _this6.data.options = [];
+    var options = (0, _core_utils.getInheritableProperty)({
       dict: params.dict,
       key: 'Opt'
     });
@@ -846,20 +905,20 @@ function (_WidgetAnnotation3) {
       for (var i = 0, ii = options.length; i < ii; i++) {
         var option = xref.fetchIfRef(options[i]);
         var isOptionArray = Array.isArray(option);
-        _this5.data.options[i] = {
+        _this6.data.options[i] = {
           exportValue: isOptionArray ? xref.fetchIfRef(option[0]) : option,
           displayValue: (0, _util.stringToPDFString)(isOptionArray ? xref.fetchIfRef(option[1]) : option)
         };
       }
     }
 
-    if (!Array.isArray(_this5.data.fieldValue)) {
-      _this5.data.fieldValue = [_this5.data.fieldValue];
+    if (!Array.isArray(_this6.data.fieldValue)) {
+      _this6.data.fieldValue = [_this6.data.fieldValue];
     }
 
-    _this5.data.combo = _this5.hasFieldFlag(_util.AnnotationFieldFlag.COMBO);
-    _this5.data.multiSelect = _this5.hasFieldFlag(_util.AnnotationFieldFlag.MULTISELECT);
-    return _this5;
+    _this6.data.combo = _this6.hasFieldFlag(_util.AnnotationFieldFlag.COMBO);
+    _this6.data.multiSelect = _this6.hasFieldFlag(_util.AnnotationFieldFlag.MULTISELECT);
+    return _this6;
   }
 
   return ChoiceWidgetAnnotation;
@@ -867,33 +926,31 @@ function (_WidgetAnnotation3) {
 
 var TextAnnotation =
 /*#__PURE__*/
-function (_Annotation2) {
-  _inherits(TextAnnotation, _Annotation2);
+function (_MarkupAnnotation) {
+  _inherits(TextAnnotation, _MarkupAnnotation);
 
   function TextAnnotation(parameters) {
-    var _this6;
+    var _this7;
 
     _classCallCheck(this, TextAnnotation);
 
     var DEFAULT_ICON_SIZE = 22;
-    _this6 = _possibleConstructorReturn(this, _getPrototypeOf(TextAnnotation).call(this, parameters));
-    _this6.data.annotationType = _util.AnnotationType.TEXT;
+    _this7 = _possibleConstructorReturn(this, _getPrototypeOf(TextAnnotation).call(this, parameters));
+    _this7.data.annotationType = _util.AnnotationType.TEXT;
 
-    if (_this6.data.hasAppearance) {
-      _this6.data.name = 'NoIcon';
+    if (_this7.data.hasAppearance) {
+      _this7.data.name = 'NoIcon';
     } else {
-      _this6.data.rect[1] = _this6.data.rect[3] - DEFAULT_ICON_SIZE;
-      _this6.data.rect[2] = _this6.data.rect[0] + DEFAULT_ICON_SIZE;
-      _this6.data.name = parameters.dict.has('Name') ? parameters.dict.get('Name').name : 'Note';
+      _this7.data.rect[1] = _this7.data.rect[3] - DEFAULT_ICON_SIZE;
+      _this7.data.rect[2] = _this7.data.rect[0] + DEFAULT_ICON_SIZE;
+      _this7.data.name = parameters.dict.has('Name') ? parameters.dict.get('Name').name : 'Note';
     }
 
-    _this6._preparePopup(parameters.dict);
-
-    return _this6;
+    return _this7;
   }
 
   return TextAnnotation;
-}(Annotation);
+}(MarkupAnnotation);
 
 var LinkAnnotation =
 /*#__PURE__*/
@@ -901,20 +958,20 @@ function (_Annotation3) {
   _inherits(LinkAnnotation, _Annotation3);
 
   function LinkAnnotation(params) {
-    var _this7;
+    var _this8;
 
     _classCallCheck(this, LinkAnnotation);
 
-    _this7 = _possibleConstructorReturn(this, _getPrototypeOf(LinkAnnotation).call(this, params));
-    _this7.data.annotationType = _util.AnnotationType.LINK;
+    _this8 = _possibleConstructorReturn(this, _getPrototypeOf(LinkAnnotation).call(this, params));
+    _this8.data.annotationType = _util.AnnotationType.LINK;
 
     _obj.Catalog.parseDestDictionary({
       destDict: params.dict,
-      resultObj: _this7.data,
+      resultObj: _this8.data,
       docBaseUrl: params.pdfManager.docBaseUrl
     });
 
-    return _this7;
+    return _this8;
   }
 
   return LinkAnnotation;
@@ -926,143 +983,158 @@ function (_Annotation4) {
   _inherits(PopupAnnotation, _Annotation4);
 
   function PopupAnnotation(parameters) {
-    var _this8;
+    var _this9;
 
     _classCallCheck(this, PopupAnnotation);
 
-    _this8 = _possibleConstructorReturn(this, _getPrototypeOf(PopupAnnotation).call(this, parameters));
-    _this8.data.annotationType = _util.AnnotationType.POPUP;
+    _this9 = _possibleConstructorReturn(this, _getPrototypeOf(PopupAnnotation).call(this, parameters));
+    _this9.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);
+      return _possibleConstructorReturn(_this9);
     }
 
     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') || '');
+    _this9.data.parentType = (0, _primitives.isName)(parentSubtype) ? parentSubtype.name : null;
+    _this9.data.parentId = dict.getRaw('Parent').toString();
+    _this9.data.title = (0, _util.stringToPDFString)(parentItem.get('T') || '');
+    _this9.data.contents = (0, _util.stringToPDFString)(parentItem.get('Contents') || '');
+
+    if (!parentItem.has('M')) {
+      _this9.data.modificationDate = null;
+    } else {
+      _this9.setModificationDate(parentItem.get('M'));
+
+      _this9.data.modificationDate = _this9.modificationDate;
+    }
 
     if (!parentItem.has('C')) {
-      _this8.data.color = null;
+      _this9.data.color = null;
     } else {
-      _this8.setColor(parentItem.getArray('C'));
+      _this9.setColor(parentItem.getArray('C'));
 
-      _this8.data.color = _this8.color;
+      _this9.data.color = _this9.color;
     }
 
-    if (!_this8.viewable) {
+    if (!_this9.viewable) {
       var parentFlags = parentItem.get('F');
 
-      if (_this8._isViewable(parentFlags)) {
-        _this8.setFlags(parentFlags);
+      if (_this9._isViewable(parentFlags)) {
+        _this9.setFlags(parentFlags);
       }
     }
 
-    return _this8;
+    return _this9;
   }
 
   return PopupAnnotation;
 }(Annotation);
 
+var FreeTextAnnotation =
+/*#__PURE__*/
+function (_MarkupAnnotation2) {
+  _inherits(FreeTextAnnotation, _MarkupAnnotation2);
+
+  function FreeTextAnnotation(parameters) {
+    var _this10;
+
+    _classCallCheck(this, FreeTextAnnotation);
+
+    _this10 = _possibleConstructorReturn(this, _getPrototypeOf(FreeTextAnnotation).call(this, parameters));
+    _this10.data.annotationType = _util.AnnotationType.FREETEXT;
+    return _this10;
+  }
+
+  return FreeTextAnnotation;
+}(MarkupAnnotation);
+
 var LineAnnotation =
 /*#__PURE__*/
-function (_Annotation5) {
-  _inherits(LineAnnotation, _Annotation5);
+function (_MarkupAnnotation3) {
+  _inherits(LineAnnotation, _MarkupAnnotation3);
 
   function LineAnnotation(parameters) {
-    var _this9;
+    var _this11;
 
     _classCallCheck(this, LineAnnotation);
 
-    _this9 = _possibleConstructorReturn(this, _getPrototypeOf(LineAnnotation).call(this, parameters));
-    _this9.data.annotationType = _util.AnnotationType.LINE;
+    _this11 = _possibleConstructorReturn(this, _getPrototypeOf(LineAnnotation).call(this, parameters));
+    _this11.data.annotationType = _util.AnnotationType.LINE;
     var dict = parameters.dict;
-    _this9.data.lineCoordinates = _util.Util.normalizeRect(dict.getArray('L'));
-
-    _this9._preparePopup(dict);
-
-    return _this9;
+    _this11.data.lineCoordinates = _util.Util.normalizeRect(dict.getArray('L'));
+    return _this11;
   }
 
   return LineAnnotation;
-}(Annotation);
+}(MarkupAnnotation);
 
 var SquareAnnotation =
 /*#__PURE__*/
-function (_Annotation6) {
-  _inherits(SquareAnnotation, _Annotation6);
+function (_MarkupAnnotation4) {
+  _inherits(SquareAnnotation, _MarkupAnnotation4);
 
   function SquareAnnotation(parameters) {
-    var _this10;
+    var _this12;
 
     _classCallCheck(this, SquareAnnotation);
 
-    _this10 = _possibleConstructorReturn(this, _getPrototypeOf(SquareAnnotation).call(this, parameters));
-    _this10.data.annotationType = _util.AnnotationType.SQUARE;
-
-    _this10._preparePopup(parameters.dict);
-
-    return _this10;
+    _this12 = _possibleConstructorReturn(this, _getPrototypeOf(SquareAnnotation).call(this, parameters));
+    _this12.data.annotationType = _util.AnnotationType.SQUARE;
+    return _this12;
   }
 
   return SquareAnnotation;
-}(Annotation);
+}(MarkupAnnotation);
 
 var CircleAnnotation =
 /*#__PURE__*/
-function (_Annotation7) {
-  _inherits(CircleAnnotation, _Annotation7);
+function (_MarkupAnnotation5) {
+  _inherits(CircleAnnotation, _MarkupAnnotation5);
 
   function CircleAnnotation(parameters) {
-    var _this11;
+    var _this13;
 
     _classCallCheck(this, CircleAnnotation);
 
-    _this11 = _possibleConstructorReturn(this, _getPrototypeOf(CircleAnnotation).call(this, parameters));
-    _this11.data.annotationType = _util.AnnotationType.CIRCLE;
-
-    _this11._preparePopup(parameters.dict);
-
-    return _this11;
+    _this13 = _possibleConstructorReturn(this, _getPrototypeOf(CircleAnnotation).call(this, parameters));
+    _this13.data.annotationType = _util.AnnotationType.CIRCLE;
+    return _this13;
   }
 
   return CircleAnnotation;
-}(Annotation);
+}(MarkupAnnotation);
 
 var PolylineAnnotation =
 /*#__PURE__*/
-function (_Annotation8) {
-  _inherits(PolylineAnnotation, _Annotation8);
+function (_MarkupAnnotation6) {
+  _inherits(PolylineAnnotation, _MarkupAnnotation6);
 
   function PolylineAnnotation(parameters) {
-    var _this12;
+    var _this14;
 
     _classCallCheck(this, PolylineAnnotation);
 
-    _this12 = _possibleConstructorReturn(this, _getPrototypeOf(PolylineAnnotation).call(this, parameters));
-    _this12.data.annotationType = _util.AnnotationType.POLYLINE;
+    _this14 = _possibleConstructorReturn(this, _getPrototypeOf(PolylineAnnotation).call(this, parameters));
+    _this14.data.annotationType = _util.AnnotationType.POLYLINE;
     var dict = parameters.dict;
     var rawVertices = dict.getArray('Vertices');
-    _this12.data.vertices = [];
+    _this14.data.vertices = [];
 
     for (var i = 0, ii = rawVertices.length; i < ii; i += 2) {
-      _this12.data.vertices.push({
+      _this14.data.vertices.push({
         x: rawVertices[i],
         y: rawVertices[i + 1]
       });
     }
 
-    _this12._preparePopup(dict);
-
-    return _this12;
+    return _this14;
   }
 
   return PolylineAnnotation;
-}(Annotation);
+}(MarkupAnnotation);
 
 var PolygonAnnotation =
 /*#__PURE__*/
@@ -1070,178 +1142,176 @@ function (_PolylineAnnotation) {
   _inherits(PolygonAnnotation, _PolylineAnnotation);
 
   function PolygonAnnotation(parameters) {
-    var _this13;
+    var _this15;
 
     _classCallCheck(this, PolygonAnnotation);
 
-    _this13 = _possibleConstructorReturn(this, _getPrototypeOf(PolygonAnnotation).call(this, parameters));
-    _this13.data.annotationType = _util.AnnotationType.POLYGON;
-    return _this13;
+    _this15 = _possibleConstructorReturn(this, _getPrototypeOf(PolygonAnnotation).call(this, parameters));
+    _this15.data.annotationType = _util.AnnotationType.POLYGON;
+    return _this15;
   }
 
   return PolygonAnnotation;
 }(PolylineAnnotation);
 
+var CaretAnnotation =
+/*#__PURE__*/
+function (_MarkupAnnotation7) {
+  _inherits(CaretAnnotation, _MarkupAnnotation7);
+
+  function CaretAnnotation(parameters) {
+    var _this16;
+
+    _classCallCheck(this, CaretAnnotation);
+
+    _this16 = _possibleConstructorReturn(this, _getPrototypeOf(CaretAnnotation).call(this, parameters));
+    _this16.data.annotationType = _util.AnnotationType.CARET;
+    return _this16;
+  }
+
+  return CaretAnnotation;
+}(MarkupAnnotation);
+
 var InkAnnotation =
 /*#__PURE__*/
-function (_Annotation9) {
-  _inherits(InkAnnotation, _Annotation9);
+function (_MarkupAnnotation8) {
+  _inherits(InkAnnotation, _MarkupAnnotation8);
 
   function InkAnnotation(parameters) {
-    var _this14;
+    var _this17;
 
     _classCallCheck(this, InkAnnotation);
 
-    _this14 = _possibleConstructorReturn(this, _getPrototypeOf(InkAnnotation).call(this, parameters));
-    _this14.data.annotationType = _util.AnnotationType.INK;
+    _this17 = _possibleConstructorReturn(this, _getPrototypeOf(InkAnnotation).call(this, parameters));
+    _this17.data.annotationType = _util.AnnotationType.INK;
     var dict = parameters.dict;
     var xref = parameters.xref;
     var originalInkLists = dict.getArray('InkList');
-    _this14.data.inkLists = [];
+    _this17.data.inkLists = [];
 
     for (var i = 0, ii = originalInkLists.length; i < ii; ++i) {
-      _this14.data.inkLists.push([]);
+      _this17.data.inkLists.push([]);
 
       for (var j = 0, jj = originalInkLists[i].length; j < jj; j += 2) {
-        _this14.data.inkLists[i].push({
+        _this17.data.inkLists[i].push({
           x: xref.fetchIfRef(originalInkLists[i][j]),
           y: xref.fetchIfRef(originalInkLists[i][j + 1])
         });
       }
     }
 
-    _this14._preparePopup(dict);
-
-    return _this14;
+    return _this17;
   }
 
   return InkAnnotation;
-}(Annotation);
+}(MarkupAnnotation);
 
 var HighlightAnnotation =
 /*#__PURE__*/
-function (_Annotation10) {
-  _inherits(HighlightAnnotation, _Annotation10);
+function (_MarkupAnnotation9) {
+  _inherits(HighlightAnnotation, _MarkupAnnotation9);
 
   function HighlightAnnotation(parameters) {
-    var _this15;
+    var _this18;
 
     _classCallCheck(this, HighlightAnnotation);
 
-    _this15 = _possibleConstructorReturn(this, _getPrototypeOf(HighlightAnnotation).call(this, parameters));
-    _this15.data.annotationType = _util.AnnotationType.HIGHLIGHT;
-
-    _this15._preparePopup(parameters.dict);
-
-    return _this15;
+    _this18 = _possibleConstructorReturn(this, _getPrototypeOf(HighlightAnnotation).call(this, parameters));
+    _this18.data.annotationType = _util.AnnotationType.HIGHLIGHT;
+    return _this18;
   }
 
   return HighlightAnnotation;
-}(Annotation);
+}(MarkupAnnotation);
 
 var UnderlineAnnotation =
 /*#__PURE__*/
-function (_Annotation11) {
-  _inherits(UnderlineAnnotation, _Annotation11);
+function (_MarkupAnnotation10) {
+  _inherits(UnderlineAnnotation, _MarkupAnnotation10);
 
   function UnderlineAnnotation(parameters) {
-    var _this16;
+    var _this19;
 
     _classCallCheck(this, UnderlineAnnotation);
 
-    _this16 = _possibleConstructorReturn(this, _getPrototypeOf(UnderlineAnnotation).call(this, parameters));
-    _this16.data.annotationType = _util.AnnotationType.UNDERLINE;
-
-    _this16._preparePopup(parameters.dict);
-
-    return _this16;
+    _this19 = _possibleConstructorReturn(this, _getPrototypeOf(UnderlineAnnotation).call(this, parameters));
+    _this19.data.annotationType = _util.AnnotationType.UNDERLINE;
+    return _this19;
   }
 
   return UnderlineAnnotation;
-}(Annotation);
+}(MarkupAnnotation);
 
 var SquigglyAnnotation =
 /*#__PURE__*/
-function (_Annotation12) {
-  _inherits(SquigglyAnnotation, _Annotation12);
+function (_MarkupAnnotation11) {
+  _inherits(SquigglyAnnotation, _MarkupAnnotation11);
 
   function SquigglyAnnotation(parameters) {
-    var _this17;
+    var _this20;
 
     _classCallCheck(this, SquigglyAnnotation);
 
-    _this17 = _possibleConstructorReturn(this, _getPrototypeOf(SquigglyAnnotation).call(this, parameters));
-    _this17.data.annotationType = _util.AnnotationType.SQUIGGLY;
-
-    _this17._preparePopup(parameters.dict);
-
-    return _this17;
+    _this20 = _possibleConstructorReturn(this, _getPrototypeOf(SquigglyAnnotation).call(this, parameters));
+    _this20.data.annotationType = _util.AnnotationType.SQUIGGLY;
+    return _this20;
   }
 
   return SquigglyAnnotation;
-}(Annotation);
+}(MarkupAnnotation);
 
 var StrikeOutAnnotation =
 /*#__PURE__*/
-function (_Annotation13) {
-  _inherits(StrikeOutAnnotation, _Annotation13);
+function (_MarkupAnnotation12) {
+  _inherits(StrikeOutAnnotation, _MarkupAnnotation12);
 
   function StrikeOutAnnotation(parameters) {
-    var _this18;
+    var _this21;
 
     _classCallCheck(this, StrikeOutAnnotation);
 
-    _this18 = _possibleConstructorReturn(this, _getPrototypeOf(StrikeOutAnnotation).call(this, parameters));
-    _this18.data.annotationType = _util.AnnotationType.STRIKEOUT;
-
-    _this18._preparePopup(parameters.dict);
-
-    return _this18;
+    _this21 = _possibleConstructorReturn(this, _getPrototypeOf(StrikeOutAnnotation).call(this, parameters));
+    _this21.data.annotationType = _util.AnnotationType.STRIKEOUT;
+    return _this21;
   }
 
   return StrikeOutAnnotation;
-}(Annotation);
+}(MarkupAnnotation);
 
 var StampAnnotation =
 /*#__PURE__*/
-function (_Annotation14) {
-  _inherits(StampAnnotation, _Annotation14);
+function (_MarkupAnnotation13) {
+  _inherits(StampAnnotation, _MarkupAnnotation13);
 
   function StampAnnotation(parameters) {
-    var _this19;
+    var _this22;
 
     _classCallCheck(this, StampAnnotation);
 
-    _this19 = _possibleConstructorReturn(this, _getPrototypeOf(StampAnnotation).call(this, parameters));
-    _this19.data.annotationType = _util.AnnotationType.STAMP;
-
-    _this19._preparePopup(parameters.dict);
-
-    return _this19;
+    _this22 = _possibleConstructorReturn(this, _getPrototypeOf(StampAnnotation).call(this, parameters));
+    _this22.data.annotationType = _util.AnnotationType.STAMP;
+    return _this22;
   }
 
   return StampAnnotation;
-}(Annotation);
+}(MarkupAnnotation);
 
 var FileAttachmentAnnotation =
 /*#__PURE__*/
-function (_Annotation15) {
-  _inherits(FileAttachmentAnnotation, _Annotation15);
+function (_MarkupAnnotation14) {
+  _inherits(FileAttachmentAnnotation, _MarkupAnnotation14);
 
   function FileAttachmentAnnotation(parameters) {
-    var _this20;
+    var _this23;
 
     _classCallCheck(this, FileAttachmentAnnotation);
 
-    _this20 = _possibleConstructorReturn(this, _getPrototypeOf(FileAttachmentAnnotation).call(this, parameters));
+    _this23 = _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;
+    _this23.data.annotationType = _util.AnnotationType.FILEATTACHMENT;
+    _this23.data.file = file.serializable;
+    return _this23;
   }
 
   return FileAttachmentAnnotation;
-}(Annotation);
+}(MarkupAnnotation);