pdfjs-dist 2.0.550 → 2.3.200

package/lib/display/annotation_layer.js

@@ -2,7 +2,7 @@
  * @licstart The following is the entire license notice for the
  * Javascript code in this page
  *
- * Copyright 2017 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.
@@ -19,81 +19,125 @@
  * @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.AnnotationLayer = undefined;
+exports.AnnotationLayer = 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 _display_utils = require("./display_utils");
 
-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 _util = require("../shared/util");
 
-var _dom_utils = require('./dom_utils');
+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); }
 
-var _util = require('../shared/util');
+function _superPropBase(object, property) { while (!Object.prototype.hasOwnProperty.call(object, property)) { object = _getPrototypeOf(object); if (object === null) break; } return object; }
 
-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 _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 _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 _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 _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 AnnotationElementFactory = 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 AnnotationElementFactory =
+/*#__PURE__*/
+function () {
   function AnnotationElementFactory() {
     _classCallCheck(this, AnnotationElementFactory);
   }
 
   _createClass(AnnotationElementFactory, null, [{
-    key: 'create',
+    key: "create",
     value: function create(parameters) {
       var subtype = parameters.data.annotationType;
+
       switch (subtype) {
         case _util.AnnotationType.LINK:
           return new LinkAnnotationElement(parameters);
+
         case _util.AnnotationType.TEXT:
           return new TextAnnotationElement(parameters);
+
         case _util.AnnotationType.WIDGET:
           var fieldType = parameters.data.fieldType;
+
           switch (fieldType) {
             case 'Tx':
               return new TextWidgetAnnotationElement(parameters);
+
             case 'Btn':
               if (parameters.data.radioButton) {
                 return new RadioButtonWidgetAnnotationElement(parameters);
               } else if (parameters.data.checkBox) {
                 return new CheckboxWidgetAnnotationElement(parameters);
               }
+
               return new PushButtonWidgetAnnotationElement(parameters);
+
             case 'Ch':
               return new ChoiceWidgetAnnotationElement(parameters);
           }
+
           return new WidgetAnnotationElement(parameters);
+
         case _util.AnnotationType.POPUP:
           return new PopupAnnotationElement(parameters);
+
+        case _util.AnnotationType.FREETEXT:
+          return new FreeTextAnnotationElement(parameters);
+
         case _util.AnnotationType.LINE:
           return new LineAnnotationElement(parameters);
+
         case _util.AnnotationType.SQUARE:
           return new SquareAnnotationElement(parameters);
+
         case _util.AnnotationType.CIRCLE:
           return new CircleAnnotationElement(parameters);
+
         case _util.AnnotationType.POLYLINE:
           return new PolylineAnnotationElement(parameters);
+
+        case _util.AnnotationType.CARET:
+          return new CaretAnnotationElement(parameters);
+
+        case _util.AnnotationType.INK:
+          return new InkAnnotationElement(parameters);
+
         case _util.AnnotationType.POLYGON:
           return new PolygonAnnotationElement(parameters);
+
         case _util.AnnotationType.HIGHLIGHT:
           return new HighlightAnnotationElement(parameters);
+
         case _util.AnnotationType.UNDERLINE:
           return new UnderlineAnnotationElement(parameters);
+
         case _util.AnnotationType.SQUIGGLY:
           return new SquigglyAnnotationElement(parameters);
+
         case _util.AnnotationType.STRIKEOUT:
           return new StrikeOutAnnotationElement(parameters);
+
         case _util.AnnotationType.STAMP:
           return new StampAnnotationElement(parameters);
+
         case _util.AnnotationType.FILEATTACHMENT:
           return new FileAttachmentAnnotationElement(parameters);
+
         default:
           return new AnnotationElement(parameters);
       }
@@ -103,7 +147,9 @@ var AnnotationElementFactory = function () {
   return AnnotationElementFactory;
 }();
 
-var AnnotationElement = function () {
+var AnnotationElement =
+/*#__PURE__*/
+function () {
   function AnnotationElement(parameters) {
     var isRenderable = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : false;
     var ignoreBorder = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : false;
@@ -120,16 +166,16 @@ var AnnotationElement = function () {
     this.imageResourcesPath = parameters.imageResourcesPath;
     this.renderInteractiveForms = parameters.renderInteractiveForms;
     this.svgFactory = parameters.svgFactory;
+
     if (isRenderable) {
       this.container = this._createContainer(ignoreBorder);
     }
   }
 
   _createClass(AnnotationElement, [{
-    key: '_createContainer',
+    key: "_createContainer",
     value: function _createContainer() {
       var ignoreBorder = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : false;
-
       var data = this.data,
           page = this.page,
           viewport = this.viewport;
@@ -137,54 +183,68 @@ var AnnotationElement = function () {
       var width = data.rect[2] - data.rect[0];
       var height = data.rect[3] - data.rect[1];
       container.setAttribute('data-annotation-id', data.id);
+
       var rect = _util.Util.normalizeRect([data.rect[0], page.view[3] - data.rect[1] + page.view[1], data.rect[2], page.view[3] - data.rect[3] + page.view[1]]);
-      container.style.transform = 'matrix(' + viewport.transform.join(',') + ')';
-      container.style.transformOrigin = -rect[0] + 'px ' + -rect[1] + 'px';
+
+      container.style.transform = "matrix(".concat(viewport.transform.join(','), ")");
+      container.style.transformOrigin = "-".concat(rect[0], "px -").concat(rect[1], "px");
+
       if (!ignoreBorder && data.borderStyle.width > 0) {
-        container.style.borderWidth = data.borderStyle.width + 'px';
+        container.style.borderWidth = "".concat(data.borderStyle.width, "px");
+
         if (data.borderStyle.style !== _util.AnnotationBorderStyleType.UNDERLINE) {
           width = width - 2 * data.borderStyle.width;
           height = height - 2 * data.borderStyle.width;
         }
+
         var horizontalRadius = data.borderStyle.horizontalCornerRadius;
         var verticalRadius = data.borderStyle.verticalCornerRadius;
+
         if (horizontalRadius > 0 || verticalRadius > 0) {
-          var radius = horizontalRadius + 'px / ' + verticalRadius + 'px';
+          var radius = "".concat(horizontalRadius, "px / ").concat(verticalRadius, "px");
           container.style.borderRadius = radius;
         }
+
         switch (data.borderStyle.style) {
           case _util.AnnotationBorderStyleType.SOLID:
             container.style.borderStyle = 'solid';
             break;
+
           case _util.AnnotationBorderStyleType.DASHED:
             container.style.borderStyle = 'dashed';
             break;
+
           case _util.AnnotationBorderStyleType.BEVELED:
             (0, _util.warn)('Unimplemented border style: beveled');
             break;
+
           case _util.AnnotationBorderStyleType.INSET:
             (0, _util.warn)('Unimplemented border style: inset');
             break;
+
           case _util.AnnotationBorderStyleType.UNDERLINE:
             container.style.borderBottomStyle = 'solid';
             break;
+
           default:
             break;
         }
+
         if (data.color) {
           container.style.borderColor = _util.Util.makeCssRgb(data.color[0] | 0, data.color[1] | 0, data.color[2] | 0);
         } else {
           container.style.borderWidth = 0;
         }
       }
-      container.style.left = rect[0] + 'px';
-      container.style.top = rect[1] + 'px';
-      container.style.width = width + 'px';
-      container.style.height = height + 'px';
+
+      container.style.left = "".concat(rect[0], "px");
+      container.style.top = "".concat(rect[1], "px");
+      container.style.width = "".concat(width, "px");
+      container.style.height = "".concat(height, "px");
       return container;
     }
   }, {
-    key: '_createPopup',
+    key: "_createPopup",
     value: function _createPopup(container, trigger, data) {
       if (!trigger) {
         trigger = document.createElement('div');
@@ -192,11 +252,13 @@ var AnnotationElement = function () {
         trigger.style.width = container.style.width;
         container.appendChild(trigger);
       }
+
       var popupElement = new PopupElement({
         container: container,
         trigger: trigger,
         color: data.color,
         title: data.title,
+        modificationDate: data.modificationDate,
         contents: data.contents,
         hideWrapper: true
       });
@@ -205,7 +267,7 @@ var AnnotationElement = function () {
       container.appendChild(popup);
     }
   }, {
-    key: 'render',
+    key: "render",
     value: function render() {
       (0, _util.unreachable)('Abstract method `AnnotationElement.render` called');
     }
@@ -214,65 +276,74 @@ var AnnotationElement = function () {
   return AnnotationElement;
 }();
 
-var LinkAnnotationElement = function (_AnnotationElement) {
+var LinkAnnotationElement =
+/*#__PURE__*/
+function (_AnnotationElement) {
   _inherits(LinkAnnotationElement, _AnnotationElement);
 
   function LinkAnnotationElement(parameters) {
     _classCallCheck(this, LinkAnnotationElement);
 
     var isRenderable = !!(parameters.data.url || parameters.data.dest || parameters.data.action);
-    return _possibleConstructorReturn(this, (LinkAnnotationElement.__proto__ || Object.getPrototypeOf(LinkAnnotationElement)).call(this, parameters, isRenderable));
+    return _possibleConstructorReturn(this, _getPrototypeOf(LinkAnnotationElement).call(this, parameters, isRenderable));
   }
 
   _createClass(LinkAnnotationElement, [{
-    key: 'render',
+    key: "render",
     value: function render() {
       this.container.className = 'linkAnnotation';
       var data = this.data,
           linkService = this.linkService;
-
       var link = document.createElement('a');
-      (0, _dom_utils.addLinkAttributes)(link, {
-        url: data.url,
-        target: data.newWindow ? _dom_utils.LinkTarget.BLANK : linkService.externalLinkTarget,
-        rel: linkService.externalLinkRel
-      });
-      if (!data.url) {
-        if (data.action) {
-          this._bindNamedAction(link, data.action);
-        } else {
-          this._bindLink(link, data.dest);
-        }
+
+      if (data.url) {
+        (0, _display_utils.addLinkAttributes)(link, {
+          url: data.url,
+          target: data.newWindow ? _display_utils.LinkTarget.BLANK : linkService.externalLinkTarget,
+          rel: linkService.externalLinkRel,
+          enabled: linkService.externalLinkEnabled
+        });
+      } else if (data.action) {
+        this._bindNamedAction(link, data.action);
+      } else {
+        this._bindLink(link, data.dest);
       }
+
       this.container.appendChild(link);
       return this.container;
     }
   }, {
-    key: '_bindLink',
+    key: "_bindLink",
     value: function _bindLink(link, destination) {
-      var _this2 = this;
+      var _this = this;
 
       link.href = this.linkService.getDestinationHash(destination);
+
       link.onclick = function () {
         if (destination) {
-          _this2.linkService.navigateTo(destination);
+          _this.linkService.navigateTo(destination);
         }
+
         return false;
       };
+
       if (destination) {
         link.className = 'internalLink';
       }
     }
   }, {
-    key: '_bindNamedAction',
+    key: "_bindNamedAction",
     value: function _bindNamedAction(link, action) {
-      var _this3 = this;
+      var _this2 = this;
 
       link.href = this.linkService.getAnchorUrl('');
+
       link.onclick = function () {
-        _this3.linkService.executeNamedAction(action);
+        _this2.linkService.executeNamedAction(action);
+
         return false;
       };
+
       link.className = 'internalLink';
     }
   }]);
@@ -280,18 +351,20 @@ var LinkAnnotationElement = function (_AnnotationElement) {
   return LinkAnnotationElement;
 }(AnnotationElement);
 
-var TextAnnotationElement = function (_AnnotationElement2) {
+var TextAnnotationElement =
+/*#__PURE__*/
+function (_AnnotationElement2) {
   _inherits(TextAnnotationElement, _AnnotationElement2);
 
   function TextAnnotationElement(parameters) {
     _classCallCheck(this, TextAnnotationElement);
 
     var isRenderable = !!(parameters.data.hasPopup || parameters.data.title || parameters.data.contents);
-    return _possibleConstructorReturn(this, (TextAnnotationElement.__proto__ || Object.getPrototypeOf(TextAnnotationElement)).call(this, parameters, isRenderable));
+    return _possibleConstructorReturn(this, _getPrototypeOf(TextAnnotationElement).call(this, parameters, isRenderable));
   }
 
   _createClass(TextAnnotationElement, [{
-    key: 'render',
+    key: "render",
     value: function render() {
       this.container.className = 'textAnnotation';
       var image = document.createElement('img');
@@ -300,10 +373,14 @@ var TextAnnotationElement = function (_AnnotationElement2) {
       image.src = this.imageResourcesPath + 'annotation-' + this.data.name.toLowerCase() + '.svg';
       image.alt = '[{{type}} Annotation]';
       image.dataset.l10nId = 'text_annotation_type';
-      image.dataset.l10nArgs = JSON.stringify({ type: this.data.name });
+      image.dataset.l10nArgs = JSON.stringify({
+        type: this.data.name
+      });
+
       if (!this.data.hasPopup) {
         this._createPopup(this.container, image, this.data);
       }
+
       this.container.appendChild(image);
       return this.container;
     }
@@ -312,17 +389,19 @@ var TextAnnotationElement = function (_AnnotationElement2) {
   return TextAnnotationElement;
 }(AnnotationElement);
 
-var WidgetAnnotationElement = function (_AnnotationElement3) {
+var WidgetAnnotationElement =
+/*#__PURE__*/
+function (_AnnotationElement3) {
   _inherits(WidgetAnnotationElement, _AnnotationElement3);
 
   function WidgetAnnotationElement() {
     _classCallCheck(this, WidgetAnnotationElement);
 
-    return _possibleConstructorReturn(this, (WidgetAnnotationElement.__proto__ || Object.getPrototypeOf(WidgetAnnotationElement)).apply(this, arguments));
+    return _possibleConstructorReturn(this, _getPrototypeOf(WidgetAnnotationElement).apply(this, arguments));
   }
 
   _createClass(WidgetAnnotationElement, [{
-    key: 'render',
+    key: "render",
     value: function render() {
       return this.container;
     }
@@ -331,22 +410,25 @@ var WidgetAnnotationElement = function (_AnnotationElement3) {
   return WidgetAnnotationElement;
 }(AnnotationElement);
 
-var TextWidgetAnnotationElement = function (_WidgetAnnotationElem) {
+var TextWidgetAnnotationElement =
+/*#__PURE__*/
+function (_WidgetAnnotationElem) {
   _inherits(TextWidgetAnnotationElement, _WidgetAnnotationElem);
 
   function TextWidgetAnnotationElement(parameters) {
     _classCallCheck(this, TextWidgetAnnotationElement);
 
     var isRenderable = parameters.renderInteractiveForms || !parameters.data.hasAppearance && !!parameters.data.fieldValue;
-    return _possibleConstructorReturn(this, (TextWidgetAnnotationElement.__proto__ || Object.getPrototypeOf(TextWidgetAnnotationElement)).call(this, parameters, isRenderable));
+    return _possibleConstructorReturn(this, _getPrototypeOf(TextWidgetAnnotationElement).call(this, parameters, isRenderable));
   }
 
   _createClass(TextWidgetAnnotationElement, [{
-    key: 'render',
+    key: "render",
     value: function render() {
       var TEXT_ALIGNMENT = ['left', 'center', 'right'];
       this.container.className = 'textWidgetAnnotation';
       var element = null;
+
       if (this.renderInteractiveForms) {
         if (this.data.multiLine) {
           element = document.createElement('textarea');
@@ -356,15 +438,18 @@ var TextWidgetAnnotationElement = function (_WidgetAnnotationElem) {
           element.type = 'text';
           element.setAttribute('value', this.data.fieldValue);
         }
+
         element.disabled = this.data.readOnly;
+
         if (this.data.maxLen !== null) {
           element.maxLength = this.data.maxLen;
         }
+
         if (this.data.comb) {
           var fieldWidth = this.data.rect[2] - this.data.rect[0];
           var combWidth = fieldWidth / this.data.maxLen;
           element.classList.add('comb');
-          element.style.letterSpacing = 'calc(' + combWidth + 'px - 1ch)';
+          element.style.letterSpacing = "calc(".concat(combWidth, "px - 1ch)");
         }
       } else {
         element = document.createElement('div');
@@ -372,29 +457,35 @@ var TextWidgetAnnotationElement = function (_WidgetAnnotationElem) {
         element.style.verticalAlign = 'middle';
         element.style.display = 'table-cell';
         var font = null;
-        if (this.data.fontRefName) {
-          font = this.page.commonObjs.getData(this.data.fontRefName);
+
+        if (this.data.fontRefName && this.page.commonObjs.has(this.data.fontRefName)) {
+          font = this.page.commonObjs.get(this.data.fontRefName);
         }
+
         this._setTextStyle(element, font);
       }
+
       if (this.data.textAlignment !== null) {
         element.style.textAlign = TEXT_ALIGNMENT[this.data.textAlignment];
       }
+
       this.container.appendChild(element);
       return this.container;
     }
   }, {
-    key: '_setTextStyle',
+    key: "_setTextStyle",
     value: function _setTextStyle(element, font) {
       var style = element.style;
-      style.fontSize = this.data.fontSize + 'px';
+      style.fontSize = "".concat(this.data.fontSize, "px");
       style.direction = this.data.fontDirection < 0 ? 'rtl' : 'ltr';
+
       if (!font) {
         return;
       }
+
       style.fontWeight = font.black ? font.bold ? '900' : 'bold' : font.bold ? 'bold' : 'normal';
       style.fontStyle = font.italic ? 'italic' : 'normal';
-      var fontFamily = font.loadedName ? '"' + font.loadedName + '", ' : '';
+      var fontFamily = font.loadedName ? "\"".concat(font.loadedName, "\", ") : '';
       var fallbackName = font.fallbackName || 'Helvetica, sans-serif';
       style.fontFamily = fontFamily + fallbackName;
     }
@@ -403,25 +494,29 @@ var TextWidgetAnnotationElement = function (_WidgetAnnotationElem) {
   return TextWidgetAnnotationElement;
 }(WidgetAnnotationElement);
 
-var CheckboxWidgetAnnotationElement = function (_WidgetAnnotationElem2) {
+var CheckboxWidgetAnnotationElement =
+/*#__PURE__*/
+function (_WidgetAnnotationElem2) {
   _inherits(CheckboxWidgetAnnotationElement, _WidgetAnnotationElem2);
 
   function CheckboxWidgetAnnotationElement(parameters) {
     _classCallCheck(this, CheckboxWidgetAnnotationElement);
 
-    return _possibleConstructorReturn(this, (CheckboxWidgetAnnotationElement.__proto__ || Object.getPrototypeOf(CheckboxWidgetAnnotationElement)).call(this, parameters, parameters.renderInteractiveForms));
+    return _possibleConstructorReturn(this, _getPrototypeOf(CheckboxWidgetAnnotationElement).call(this, parameters, parameters.renderInteractiveForms));
   }
 
   _createClass(CheckboxWidgetAnnotationElement, [{
-    key: 'render',
+    key: "render",
     value: function render() {
       this.container.className = 'buttonWidgetAnnotation checkBox';
       var element = document.createElement('input');
       element.disabled = this.data.readOnly;
       element.type = 'checkbox';
+
       if (this.data.fieldValue && this.data.fieldValue !== 'Off') {
         element.setAttribute('checked', true);
       }
+
       this.container.appendChild(element);
       return this.container;
     }
@@ -430,26 +525,30 @@ var CheckboxWidgetAnnotationElement = function (_WidgetAnnotationElem2) {
   return CheckboxWidgetAnnotationElement;
 }(WidgetAnnotationElement);
 
-var RadioButtonWidgetAnnotationElement = function (_WidgetAnnotationElem3) {
+var RadioButtonWidgetAnnotationElement =
+/*#__PURE__*/
+function (_WidgetAnnotationElem3) {
   _inherits(RadioButtonWidgetAnnotationElement, _WidgetAnnotationElem3);
 
   function RadioButtonWidgetAnnotationElement(parameters) {
     _classCallCheck(this, RadioButtonWidgetAnnotationElement);
 
-    return _possibleConstructorReturn(this, (RadioButtonWidgetAnnotationElement.__proto__ || Object.getPrototypeOf(RadioButtonWidgetAnnotationElement)).call(this, parameters, parameters.renderInteractiveForms));
+    return _possibleConstructorReturn(this, _getPrototypeOf(RadioButtonWidgetAnnotationElement).call(this, parameters, parameters.renderInteractiveForms));
   }
 
   _createClass(RadioButtonWidgetAnnotationElement, [{
-    key: 'render',
+    key: "render",
     value: function render() {
       this.container.className = 'buttonWidgetAnnotation radioButton';
       var element = document.createElement('input');
       element.disabled = this.data.readOnly;
       element.type = 'radio';
       element.name = this.data.fieldName;
+
       if (this.data.fieldValue === this.data.buttonValue) {
         element.setAttribute('checked', true);
       }
+
       this.container.appendChild(element);
       return this.container;
     }
@@ -458,19 +557,22 @@ var RadioButtonWidgetAnnotationElement = function (_WidgetAnnotationElem3) {
   return RadioButtonWidgetAnnotationElement;
 }(WidgetAnnotationElement);
 
-var PushButtonWidgetAnnotationElement = function (_LinkAnnotationElemen) {
+var PushButtonWidgetAnnotationElement =
+/*#__PURE__*/
+function (_LinkAnnotationElemen) {
   _inherits(PushButtonWidgetAnnotationElement, _LinkAnnotationElemen);
 
   function PushButtonWidgetAnnotationElement() {
     _classCallCheck(this, PushButtonWidgetAnnotationElement);
 
-    return _possibleConstructorReturn(this, (PushButtonWidgetAnnotationElement.__proto__ || Object.getPrototypeOf(PushButtonWidgetAnnotationElement)).apply(this, arguments));
+    return _possibleConstructorReturn(this, _getPrototypeOf(PushButtonWidgetAnnotationElement).apply(this, arguments));
   }
 
   _createClass(PushButtonWidgetAnnotationElement, [{
-    key: 'render',
+    key: "render",
     value: function render() {
-      var container = _get(PushButtonWidgetAnnotationElement.prototype.__proto__ || Object.getPrototypeOf(PushButtonWidgetAnnotationElement.prototype), 'render', this).call(this);
+      var container = _get(_getPrototypeOf(PushButtonWidgetAnnotationElement.prototype), "render", this).call(this);
+
       container.className = 'buttonWidgetAnnotation pushButton';
       return container;
     }
@@ -479,37 +581,64 @@ var PushButtonWidgetAnnotationElement = function (_LinkAnnotationElemen) {
   return PushButtonWidgetAnnotationElement;
 }(LinkAnnotationElement);
 
-var ChoiceWidgetAnnotationElement = function (_WidgetAnnotationElem4) {
+var ChoiceWidgetAnnotationElement =
+/*#__PURE__*/
+function (_WidgetAnnotationElem4) {
   _inherits(ChoiceWidgetAnnotationElement, _WidgetAnnotationElem4);
 
   function ChoiceWidgetAnnotationElement(parameters) {
     _classCallCheck(this, ChoiceWidgetAnnotationElement);
 
-    return _possibleConstructorReturn(this, (ChoiceWidgetAnnotationElement.__proto__ || Object.getPrototypeOf(ChoiceWidgetAnnotationElement)).call(this, parameters, parameters.renderInteractiveForms));
+    return _possibleConstructorReturn(this, _getPrototypeOf(ChoiceWidgetAnnotationElement).call(this, parameters, parameters.renderInteractiveForms));
   }
 
   _createClass(ChoiceWidgetAnnotationElement, [{
-    key: 'render',
+    key: "render",
     value: function render() {
       this.container.className = 'choiceWidgetAnnotation';
       var selectElement = document.createElement('select');
       selectElement.disabled = this.data.readOnly;
+
       if (!this.data.combo) {
         selectElement.size = this.data.options.length;
+
         if (this.data.multiSelect) {
           selectElement.multiple = true;
         }
       }
-      for (var i = 0, ii = this.data.options.length; i < ii; i++) {
-        var option = this.data.options[i];
-        var optionElement = document.createElement('option');
-        optionElement.textContent = option.displayValue;
-        optionElement.value = option.exportValue;
-        if (this.data.fieldValue.includes(option.displayValue)) {
-          optionElement.setAttribute('selected', true);
+
+      var _iteratorNormalCompletion = true;
+      var _didIteratorError = false;
+      var _iteratorError = undefined;
+
+      try {
+        for (var _iterator = this.data.options[Symbol.iterator](), _step; !(_iteratorNormalCompletion = (_step = _iterator.next()).done); _iteratorNormalCompletion = true) {
+          var option = _step.value;
+          var optionElement = document.createElement('option');
+          optionElement.textContent = option.displayValue;
+          optionElement.value = option.exportValue;
+
+          if (this.data.fieldValue.includes(option.displayValue)) {
+            optionElement.setAttribute('selected', true);
+          }
+
+          selectElement.appendChild(optionElement);
+        }
+      } catch (err) {
+        _didIteratorError = true;
+        _iteratorError = err;
+      } finally {
+        try {
+          if (!_iteratorNormalCompletion && _iterator["return"] != null) {
+            _iterator["return"]();
+          }
+        } finally {
+          if (_didIteratorError) {
+            throw _iteratorError;
+          }
         }
-        selectElement.appendChild(optionElement);
       }
+
       this.container.appendChild(selectElement);
       return this.container;
     }
@@ -518,40 +647,47 @@ var ChoiceWidgetAnnotationElement = function (_WidgetAnnotationElem4) {
   return ChoiceWidgetAnnotationElement;
 }(WidgetAnnotationElement);
 
-var PopupAnnotationElement = function (_AnnotationElement4) {
+var PopupAnnotationElement =
+/*#__PURE__*/
+function (_AnnotationElement4) {
   _inherits(PopupAnnotationElement, _AnnotationElement4);
 
   function PopupAnnotationElement(parameters) {
     _classCallCheck(this, PopupAnnotationElement);
 
     var isRenderable = !!(parameters.data.title || parameters.data.contents);
-    return _possibleConstructorReturn(this, (PopupAnnotationElement.__proto__ || Object.getPrototypeOf(PopupAnnotationElement)).call(this, parameters, isRenderable));
+    return _possibleConstructorReturn(this, _getPrototypeOf(PopupAnnotationElement).call(this, parameters, isRenderable));
   }
 
   _createClass(PopupAnnotationElement, [{
-    key: 'render',
+    key: "render",
     value: function render() {
-      var IGNORE_TYPES = ['Line', 'Square', 'Circle', 'PolyLine', 'Polygon'];
+      var IGNORE_TYPES = ['Line', 'Square', 'Circle', 'PolyLine', 'Polygon', 'Ink'];
       this.container.className = 'popupAnnotation';
+
       if (IGNORE_TYPES.includes(this.data.parentType)) {
         return this.container;
       }
-      var selector = '[data-annotation-id="' + this.data.parentId + '"]';
+
+      var selector = "[data-annotation-id=\"".concat(this.data.parentId, "\"]");
       var parentElement = this.layer.querySelector(selector);
+
       if (!parentElement) {
         return this.container;
       }
+
       var popup = new PopupElement({
         container: this.container,
         trigger: parentElement,
         color: this.data.color,
         title: this.data.title,
+        modificationDate: this.data.modificationDate,
         contents: this.data.contents
       });
       var parentLeft = parseFloat(parentElement.style.left);
       var parentWidth = parseFloat(parentElement.style.width);
-      this.container.style.transformOrigin = -(parentLeft + parentWidth) + 'px -' + parentElement.style.top;
-      this.container.style.left = parentLeft + parentWidth + 'px';
+      this.container.style.transformOrigin = "-".concat(parentLeft + parentWidth, "px -").concat(parentElement.style.top);
+      this.container.style.left = "".concat(parentLeft + parentWidth, "px");
       this.container.appendChild(popup.render());
       return this.container;
     }
@@ -560,7 +696,9 @@ var PopupAnnotationElement = function (_AnnotationElement4) {
   return PopupAnnotationElement;
 }(AnnotationElement);
 
-var PopupElement = function () {
+var PopupElement =
+/*#__PURE__*/
+function () {
   function PopupElement(parameters) {
     _classCallCheck(this, PopupElement);
 
@@ -568,13 +706,14 @@ var PopupElement = function () {
     this.trigger = parameters.trigger;
     this.color = parameters.color;
     this.title = parameters.title;
+    this.modificationDate = parameters.modificationDate;
     this.contents = parameters.contents;
     this.hideWrapper = parameters.hideWrapper || false;
     this.pinned = false;
   }
 
   _createClass(PopupElement, [{
-    key: 'render',
+    key: "render",
     value: function render() {
       var BACKGROUND_ENLIGHT = 0.7;
       var wrapper = document.createElement('div');
@@ -584,40 +723,60 @@ var PopupElement = function () {
       var popup = document.createElement('div');
       popup.className = 'popup';
       var color = this.color;
+
       if (color) {
         var r = BACKGROUND_ENLIGHT * (255 - color[0]) + color[0];
         var g = BACKGROUND_ENLIGHT * (255 - color[1]) + color[1];
         var b = BACKGROUND_ENLIGHT * (255 - color[2]) + color[2];
         popup.style.backgroundColor = _util.Util.makeCssRgb(r | 0, g | 0, b | 0);
       }
-      var contents = this._formatContents(this.contents);
+
       var title = document.createElement('h1');
       title.textContent = this.title;
+      popup.appendChild(title);
+
+      var dateObject = _display_utils.PDFDateString.toDateObject(this.modificationDate);
+
+      if (dateObject) {
+        var modificationDate = document.createElement('span');
+        modificationDate.textContent = '{{date}}, {{time}}';
+        modificationDate.dataset.l10nId = 'annotation_date_string';
+        modificationDate.dataset.l10nArgs = JSON.stringify({
+          date: dateObject.toLocaleDateString(),
+          time: dateObject.toLocaleTimeString()
+        });
+        popup.appendChild(modificationDate);
+      }
+
+      var contents = this._formatContents(this.contents);
+
+      popup.appendChild(contents);
       this.trigger.addEventListener('click', this._toggle.bind(this));
       this.trigger.addEventListener('mouseover', this._show.bind(this, false));
       this.trigger.addEventListener('mouseout', this._hide.bind(this, false));
       popup.addEventListener('click', this._hide.bind(this, true));
-      popup.appendChild(title);
-      popup.appendChild(contents);
       wrapper.appendChild(popup);
       return wrapper;
     }
   }, {
-    key: '_formatContents',
+    key: "_formatContents",
     value: function _formatContents(contents) {
       var p = document.createElement('p');
       var lines = contents.split(/(?:\r\n?|\n)/);
+
       for (var i = 0, ii = lines.length; i < ii; ++i) {
         var line = lines[i];
         p.appendChild(document.createTextNode(line));
+
         if (i < ii - 1) {
           p.appendChild(document.createElement('br'));
         }
       }
+
       return p;
     }
   }, {
-    key: '_toggle',
+    key: "_toggle",
     value: function _toggle() {
       if (this.pinned) {
         this._hide(true);
@@ -626,26 +785,28 @@ var PopupElement = function () {
       }
     }
   }, {
-    key: '_show',
+    key: "_show",
     value: function _show() {
       var pin = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : false;
 
       if (pin) {
         this.pinned = true;
       }
+
       if (this.hideElement.hasAttribute('hidden')) {
         this.hideElement.removeAttribute('hidden');
         this.container.style.zIndex += 1;
       }
     }
   }, {
-    key: '_hide',
+    key: "_hide",
     value: function _hide() {
       var unpin = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : true;
 
       if (unpin) {
         this.pinned = false;
       }
+
       if (!this.hideElement.hasAttribute('hidden') && !this.pinned) {
         this.hideElement.setAttribute('hidden', true);
         this.container.style.zIndex -= 1;
@@ -656,18 +817,48 @@ var PopupElement = function () {
   return PopupElement;
 }();
 
-var LineAnnotationElement = function (_AnnotationElement5) {
-  _inherits(LineAnnotationElement, _AnnotationElement5);
+var FreeTextAnnotationElement =
+/*#__PURE__*/
+function (_AnnotationElement5) {
+  _inherits(FreeTextAnnotationElement, _AnnotationElement5);
+
+  function FreeTextAnnotationElement(parameters) {
+    _classCallCheck(this, FreeTextAnnotationElement);
+
+    var isRenderable = !!(parameters.data.hasPopup || parameters.data.title || parameters.data.contents);
+    return _possibleConstructorReturn(this, _getPrototypeOf(FreeTextAnnotationElement).call(this, parameters, isRenderable, true));
+  }
+
+  _createClass(FreeTextAnnotationElement, [{
+    key: "render",
+    value: function render() {
+      this.container.className = 'freeTextAnnotation';
+
+      if (!this.data.hasPopup) {
+        this._createPopup(this.container, null, this.data);
+      }
+
+      return this.container;
+    }
+  }]);
+
+  return FreeTextAnnotationElement;
+}(AnnotationElement);
+
+var LineAnnotationElement =
+/*#__PURE__*/
+function (_AnnotationElement6) {
+  _inherits(LineAnnotationElement, _AnnotationElement6);
 
   function LineAnnotationElement(parameters) {
     _classCallCheck(this, LineAnnotationElement);
 
     var isRenderable = !!(parameters.data.hasPopup || parameters.data.title || parameters.data.contents);
-    return _possibleConstructorReturn(this, (LineAnnotationElement.__proto__ || Object.getPrototypeOf(LineAnnotationElement)).call(this, parameters, isRenderable, true));
+    return _possibleConstructorReturn(this, _getPrototypeOf(LineAnnotationElement).call(this, parameters, isRenderable, true));
   }
 
   _createClass(LineAnnotationElement, [{
-    key: 'render',
+    key: "render",
     value: function render() {
       this.container.className = 'lineAnnotation';
       var data = this.data;
@@ -683,7 +874,9 @@ var LineAnnotationElement = function (_AnnotationElement5) {
       line.setAttribute('stroke', 'transparent');
       svg.appendChild(line);
       this.container.append(svg);
+
       this._createPopup(this.container, line, data);
+
       return this.container;
     }
   }]);
@@ -691,18 +884,20 @@ var LineAnnotationElement = function (_AnnotationElement5) {
   return LineAnnotationElement;
 }(AnnotationElement);
 
-var SquareAnnotationElement = function (_AnnotationElement6) {
-  _inherits(SquareAnnotationElement, _AnnotationElement6);
+var SquareAnnotationElement =
+/*#__PURE__*/
+function (_AnnotationElement7) {
+  _inherits(SquareAnnotationElement, _AnnotationElement7);
 
   function SquareAnnotationElement(parameters) {
     _classCallCheck(this, SquareAnnotationElement);
 
     var isRenderable = !!(parameters.data.hasPopup || parameters.data.title || parameters.data.contents);
-    return _possibleConstructorReturn(this, (SquareAnnotationElement.__proto__ || Object.getPrototypeOf(SquareAnnotationElement)).call(this, parameters, isRenderable, true));
+    return _possibleConstructorReturn(this, _getPrototypeOf(SquareAnnotationElement).call(this, parameters, isRenderable, true));
   }
 
   _createClass(SquareAnnotationElement, [{
-    key: 'render',
+    key: "render",
     value: function render() {
       this.container.className = 'squareAnnotation';
       var data = this.data;
@@ -720,7 +915,9 @@ var SquareAnnotationElement = function (_AnnotationElement6) {
       square.setAttribute('fill', 'none');
       svg.appendChild(square);
       this.container.append(svg);
+
       this._createPopup(this.container, square, data);
+
       return this.container;
     }
   }]);
@@ -728,18 +925,20 @@ var SquareAnnotationElement = function (_AnnotationElement6) {
   return SquareAnnotationElement;
 }(AnnotationElement);
 
-var CircleAnnotationElement = function (_AnnotationElement7) {
-  _inherits(CircleAnnotationElement, _AnnotationElement7);
+var CircleAnnotationElement =
+/*#__PURE__*/
+function (_AnnotationElement8) {
+  _inherits(CircleAnnotationElement, _AnnotationElement8);
 
   function CircleAnnotationElement(parameters) {
     _classCallCheck(this, CircleAnnotationElement);
 
     var isRenderable = !!(parameters.data.hasPopup || parameters.data.title || parameters.data.contents);
-    return _possibleConstructorReturn(this, (CircleAnnotationElement.__proto__ || Object.getPrototypeOf(CircleAnnotationElement)).call(this, parameters, isRenderable, true));
+    return _possibleConstructorReturn(this, _getPrototypeOf(CircleAnnotationElement).call(this, parameters, isRenderable, true));
   }
 
   _createClass(CircleAnnotationElement, [{
-    key: 'render',
+    key: "render",
     value: function render() {
       this.container.className = 'circleAnnotation';
       var data = this.data;
@@ -757,7 +956,9 @@ var CircleAnnotationElement = function (_AnnotationElement7) {
       circle.setAttribute('fill', 'none');
       svg.appendChild(circle);
       this.container.append(svg);
+
       this._createPopup(this.container, circle, data);
+
       return this.container;
     }
   }]);
@@ -765,46 +966,69 @@ var CircleAnnotationElement = function (_AnnotationElement7) {
   return CircleAnnotationElement;
 }(AnnotationElement);
 
-var PolylineAnnotationElement = function (_AnnotationElement8) {
-  _inherits(PolylineAnnotationElement, _AnnotationElement8);
+var PolylineAnnotationElement =
+/*#__PURE__*/
+function (_AnnotationElement9) {
+  _inherits(PolylineAnnotationElement, _AnnotationElement9);
 
   function PolylineAnnotationElement(parameters) {
+    var _this3;
+
     _classCallCheck(this, PolylineAnnotationElement);
 
     var isRenderable = !!(parameters.data.hasPopup || parameters.data.title || parameters.data.contents);
-
-    var _this15 = _possibleConstructorReturn(this, (PolylineAnnotationElement.__proto__ || Object.getPrototypeOf(PolylineAnnotationElement)).call(this, parameters, isRenderable, true));
-
-    _this15.containerClassName = 'polylineAnnotation';
-    _this15.svgElementName = 'svg:polyline';
-    return _this15;
+    _this3 = _possibleConstructorReturn(this, _getPrototypeOf(PolylineAnnotationElement).call(this, parameters, isRenderable, true));
+    _this3.containerClassName = 'polylineAnnotation';
+    _this3.svgElementName = 'svg:polyline';
+    return _this3;
   }
 
   _createClass(PolylineAnnotationElement, [{
-    key: 'render',
+    key: "render",
     value: function render() {
       this.container.className = this.containerClassName;
       var data = this.data;
       var width = data.rect[2] - data.rect[0];
       var height = data.rect[3] - data.rect[1];
       var svg = this.svgFactory.create(width, height);
-      var vertices = data.vertices;
       var points = [];
-      for (var i = 0, ii = vertices.length; i < ii; i++) {
-        var x = vertices[i].x - data.rect[0];
-        var y = data.rect[3] - vertices[i].y;
-        points.push(x + ',' + y);
+      var _iteratorNormalCompletion2 = true;
+      var _didIteratorError2 = false;
+      var _iteratorError2 = undefined;
+
+      try {
+        for (var _iterator2 = data.vertices[Symbol.iterator](), _step2; !(_iteratorNormalCompletion2 = (_step2 = _iterator2.next()).done); _iteratorNormalCompletion2 = true) {
+          var coordinate = _step2.value;
+          var x = coordinate.x - data.rect[0];
+          var y = data.rect[3] - coordinate.y;
+          points.push(x + ',' + y);
+        }
+      } catch (err) {
+        _didIteratorError2 = true;
+        _iteratorError2 = err;
+      } finally {
+        try {
+          if (!_iteratorNormalCompletion2 && _iterator2["return"] != null) {
+            _iterator2["return"]();
+          }
+        } finally {
+          if (_didIteratorError2) {
+            throw _iteratorError2;
+          }
+        }
       }
+
       points = points.join(' ');
-      var borderWidth = data.borderStyle.width;
       var polyline = this.svgFactory.createElement(this.svgElementName);
       polyline.setAttribute('points', points);
-      polyline.setAttribute('stroke-width', borderWidth);
+      polyline.setAttribute('stroke-width', data.borderStyle.width);
       polyline.setAttribute('stroke', 'transparent');
       polyline.setAttribute('fill', 'none');
       svg.appendChild(polyline);
       this.container.append(svg);
+
       this._createPopup(this.container, polyline, data);
+
       return this.container;
     }
   }]);
@@ -812,39 +1036,167 @@ var PolylineAnnotationElement = function (_AnnotationElement8) {
   return PolylineAnnotationElement;
 }(AnnotationElement);
 
-var PolygonAnnotationElement = function (_PolylineAnnotationEl) {
+var PolygonAnnotationElement =
+/*#__PURE__*/
+function (_PolylineAnnotationEl) {
   _inherits(PolygonAnnotationElement, _PolylineAnnotationEl);
 
   function PolygonAnnotationElement(parameters) {
-    _classCallCheck(this, PolygonAnnotationElement);
+    var _this4;
 
-    var _this16 = _possibleConstructorReturn(this, (PolygonAnnotationElement.__proto__ || Object.getPrototypeOf(PolygonAnnotationElement)).call(this, parameters));
+    _classCallCheck(this, PolygonAnnotationElement);
 
-    _this16.containerClassName = 'polygonAnnotation';
-    _this16.svgElementName = 'svg:polygon';
-    return _this16;
+    _this4 = _possibleConstructorReturn(this, _getPrototypeOf(PolygonAnnotationElement).call(this, parameters));
+    _this4.containerClassName = 'polygonAnnotation';
+    _this4.svgElementName = 'svg:polygon';
+    return _this4;
   }
 
   return PolygonAnnotationElement;
 }(PolylineAnnotationElement);
 
-var HighlightAnnotationElement = function (_AnnotationElement9) {
-  _inherits(HighlightAnnotationElement, _AnnotationElement9);
+var CaretAnnotationElement =
+/*#__PURE__*/
+function (_AnnotationElement10) {
+  _inherits(CaretAnnotationElement, _AnnotationElement10);
+
+  function CaretAnnotationElement(parameters) {
+    _classCallCheck(this, CaretAnnotationElement);
+
+    var isRenderable = !!(parameters.data.hasPopup || parameters.data.title || parameters.data.contents);
+    return _possibleConstructorReturn(this, _getPrototypeOf(CaretAnnotationElement).call(this, parameters, isRenderable, true));
+  }
+
+  _createClass(CaretAnnotationElement, [{
+    key: "render",
+    value: function render() {
+      this.container.className = 'caretAnnotation';
+
+      if (!this.data.hasPopup) {
+        this._createPopup(this.container, null, this.data);
+      }
+
+      return this.container;
+    }
+  }]);
+
+  return CaretAnnotationElement;
+}(AnnotationElement);
+
+var InkAnnotationElement =
+/*#__PURE__*/
+function (_AnnotationElement11) {
+  _inherits(InkAnnotationElement, _AnnotationElement11);
+
+  function InkAnnotationElement(parameters) {
+    var _this5;
+
+    _classCallCheck(this, InkAnnotationElement);
+
+    var isRenderable = !!(parameters.data.hasPopup || parameters.data.title || parameters.data.contents);
+    _this5 = _possibleConstructorReturn(this, _getPrototypeOf(InkAnnotationElement).call(this, parameters, isRenderable, true));
+    _this5.containerClassName = 'inkAnnotation';
+    _this5.svgElementName = 'svg:polyline';
+    return _this5;
+  }
+
+  _createClass(InkAnnotationElement, [{
+    key: "render",
+    value: function render() {
+      this.container.className = this.containerClassName;
+      var data = this.data;
+      var width = data.rect[2] - data.rect[0];
+      var height = data.rect[3] - data.rect[1];
+      var svg = this.svgFactory.create(width, height);
+      var _iteratorNormalCompletion3 = true;
+      var _didIteratorError3 = false;
+      var _iteratorError3 = undefined;
+
+      try {
+        for (var _iterator3 = data.inkLists[Symbol.iterator](), _step3; !(_iteratorNormalCompletion3 = (_step3 = _iterator3.next()).done); _iteratorNormalCompletion3 = true) {
+          var inkList = _step3.value;
+          var points = [];
+          var _iteratorNormalCompletion4 = true;
+          var _didIteratorError4 = false;
+          var _iteratorError4 = undefined;
+
+          try {
+            for (var _iterator4 = inkList[Symbol.iterator](), _step4; !(_iteratorNormalCompletion4 = (_step4 = _iterator4.next()).done); _iteratorNormalCompletion4 = true) {
+              var coordinate = _step4.value;
+              var x = coordinate.x - data.rect[0];
+              var y = data.rect[3] - coordinate.y;
+              points.push("".concat(x, ",").concat(y));
+            }
+          } catch (err) {
+            _didIteratorError4 = true;
+            _iteratorError4 = err;
+          } finally {
+            try {
+              if (!_iteratorNormalCompletion4 && _iterator4["return"] != null) {
+                _iterator4["return"]();
+              }
+            } finally {
+              if (_didIteratorError4) {
+                throw _iteratorError4;
+              }
+            }
+          }
+
+          points = points.join(' ');
+          var polyline = this.svgFactory.createElement(this.svgElementName);
+          polyline.setAttribute('points', points);
+          polyline.setAttribute('stroke-width', data.borderStyle.width);
+          polyline.setAttribute('stroke', 'transparent');
+          polyline.setAttribute('fill', 'none');
+
+          this._createPopup(this.container, polyline, data);
+
+          svg.appendChild(polyline);
+        }
+      } catch (err) {
+        _didIteratorError3 = true;
+        _iteratorError3 = err;
+      } finally {
+        try {
+          if (!_iteratorNormalCompletion3 && _iterator3["return"] != null) {
+            _iterator3["return"]();
+          }
+        } finally {
+          if (_didIteratorError3) {
+            throw _iteratorError3;
+          }
+        }
+      }
+
+      this.container.append(svg);
+      return this.container;
+    }
+  }]);
+
+  return InkAnnotationElement;
+}(AnnotationElement);
+
+var HighlightAnnotationElement =
+/*#__PURE__*/
+function (_AnnotationElement12) {
+  _inherits(HighlightAnnotationElement, _AnnotationElement12);
 
   function HighlightAnnotationElement(parameters) {
     _classCallCheck(this, HighlightAnnotationElement);
 
     var isRenderable = !!(parameters.data.hasPopup || parameters.data.title || parameters.data.contents);
-    return _possibleConstructorReturn(this, (HighlightAnnotationElement.__proto__ || Object.getPrototypeOf(HighlightAnnotationElement)).call(this, parameters, isRenderable, true));
+    return _possibleConstructorReturn(this, _getPrototypeOf(HighlightAnnotationElement).call(this, parameters, isRenderable, true));
   }
 
   _createClass(HighlightAnnotationElement, [{
-    key: 'render',
+    key: "render",
     value: function render() {
       this.container.className = 'highlightAnnotation';
+
       if (!this.data.hasPopup) {
         this._createPopup(this.container, null, this.data);
       }
+
       return this.container;
     }
   }]);
@@ -852,23 +1204,27 @@ var HighlightAnnotationElement = function (_AnnotationElement9) {
   return HighlightAnnotationElement;
 }(AnnotationElement);
 
-var UnderlineAnnotationElement = function (_AnnotationElement10) {
-  _inherits(UnderlineAnnotationElement, _AnnotationElement10);
+var UnderlineAnnotationElement =
+/*#__PURE__*/
+function (_AnnotationElement13) {
+  _inherits(UnderlineAnnotationElement, _AnnotationElement13);
 
   function UnderlineAnnotationElement(parameters) {
     _classCallCheck(this, UnderlineAnnotationElement);
 
     var isRenderable = !!(parameters.data.hasPopup || parameters.data.title || parameters.data.contents);
-    return _possibleConstructorReturn(this, (UnderlineAnnotationElement.__proto__ || Object.getPrototypeOf(UnderlineAnnotationElement)).call(this, parameters, isRenderable, true));
+    return _possibleConstructorReturn(this, _getPrototypeOf(UnderlineAnnotationElement).call(this, parameters, isRenderable, true));
   }
 
   _createClass(UnderlineAnnotationElement, [{
-    key: 'render',
+    key: "render",
     value: function render() {
       this.container.className = 'underlineAnnotation';
+
       if (!this.data.hasPopup) {
         this._createPopup(this.container, null, this.data);
       }
+
       return this.container;
     }
   }]);
@@ -876,23 +1232,27 @@ var UnderlineAnnotationElement = function (_AnnotationElement10) {
   return UnderlineAnnotationElement;
 }(AnnotationElement);
 
-var SquigglyAnnotationElement = function (_AnnotationElement11) {
-  _inherits(SquigglyAnnotationElement, _AnnotationElement11);
+var SquigglyAnnotationElement =
+/*#__PURE__*/
+function (_AnnotationElement14) {
+  _inherits(SquigglyAnnotationElement, _AnnotationElement14);
 
   function SquigglyAnnotationElement(parameters) {
     _classCallCheck(this, SquigglyAnnotationElement);
 
     var isRenderable = !!(parameters.data.hasPopup || parameters.data.title || parameters.data.contents);
-    return _possibleConstructorReturn(this, (SquigglyAnnotationElement.__proto__ || Object.getPrototypeOf(SquigglyAnnotationElement)).call(this, parameters, isRenderable, true));
+    return _possibleConstructorReturn(this, _getPrototypeOf(SquigglyAnnotationElement).call(this, parameters, isRenderable, true));
   }
 
   _createClass(SquigglyAnnotationElement, [{
-    key: 'render',
+    key: "render",
     value: function render() {
       this.container.className = 'squigglyAnnotation';
+
       if (!this.data.hasPopup) {
         this._createPopup(this.container, null, this.data);
       }
+
       return this.container;
     }
   }]);
@@ -900,23 +1260,27 @@ var SquigglyAnnotationElement = function (_AnnotationElement11) {
   return SquigglyAnnotationElement;
 }(AnnotationElement);
 
-var StrikeOutAnnotationElement = function (_AnnotationElement12) {
-  _inherits(StrikeOutAnnotationElement, _AnnotationElement12);
+var StrikeOutAnnotationElement =
+/*#__PURE__*/
+function (_AnnotationElement15) {
+  _inherits(StrikeOutAnnotationElement, _AnnotationElement15);
 
   function StrikeOutAnnotationElement(parameters) {
     _classCallCheck(this, StrikeOutAnnotationElement);
 
     var isRenderable = !!(parameters.data.hasPopup || parameters.data.title || parameters.data.contents);
-    return _possibleConstructorReturn(this, (StrikeOutAnnotationElement.__proto__ || Object.getPrototypeOf(StrikeOutAnnotationElement)).call(this, parameters, isRenderable, true));
+    return _possibleConstructorReturn(this, _getPrototypeOf(StrikeOutAnnotationElement).call(this, parameters, isRenderable, true));
   }
 
   _createClass(StrikeOutAnnotationElement, [{
-    key: 'render',
+    key: "render",
     value: function render() {
       this.container.className = 'strikeoutAnnotation';
+
       if (!this.data.hasPopup) {
         this._createPopup(this.container, null, this.data);
       }
+
       return this.container;
     }
   }]);
@@ -924,23 +1288,27 @@ var StrikeOutAnnotationElement = function (_AnnotationElement12) {
   return StrikeOutAnnotationElement;
 }(AnnotationElement);
 
-var StampAnnotationElement = function (_AnnotationElement13) {
-  _inherits(StampAnnotationElement, _AnnotationElement13);
+var StampAnnotationElement =
+/*#__PURE__*/
+function (_AnnotationElement16) {
+  _inherits(StampAnnotationElement, _AnnotationElement16);
 
   function StampAnnotationElement(parameters) {
     _classCallCheck(this, StampAnnotationElement);
 
     var isRenderable = !!(parameters.data.hasPopup || parameters.data.title || parameters.data.contents);
-    return _possibleConstructorReturn(this, (StampAnnotationElement.__proto__ || Object.getPrototypeOf(StampAnnotationElement)).call(this, parameters, isRenderable, true));
+    return _possibleConstructorReturn(this, _getPrototypeOf(StampAnnotationElement).call(this, parameters, isRenderable, true));
   }
 
   _createClass(StampAnnotationElement, [{
-    key: 'render',
+    key: "render",
     value: function render() {
       this.container.className = 'stampAnnotation';
+
       if (!this.data.hasPopup) {
         this._createPopup(this.container, null, this.data);
       }
+
       return this.container;
     }
   }]);
@@ -948,46 +1316,59 @@ var StampAnnotationElement = function (_AnnotationElement13) {
   return StampAnnotationElement;
 }(AnnotationElement);
 
-var FileAttachmentAnnotationElement = function (_AnnotationElement14) {
-  _inherits(FileAttachmentAnnotationElement, _AnnotationElement14);
+var FileAttachmentAnnotationElement =
+/*#__PURE__*/
+function (_AnnotationElement17) {
+  _inherits(FileAttachmentAnnotationElement, _AnnotationElement17);
 
   function FileAttachmentAnnotationElement(parameters) {
+    var _this6;
+
     _classCallCheck(this, FileAttachmentAnnotationElement);
 
-    var _this22 = _possibleConstructorReturn(this, (FileAttachmentAnnotationElement.__proto__ || Object.getPrototypeOf(FileAttachmentAnnotationElement)).call(this, parameters, true));
-
-    var file = _this22.data.file;
-    _this22.filename = (0, _dom_utils.getFilenameFromUrl)(file.filename);
-    _this22.content = file.content;
-    _this22.linkService.onFileAttachmentAnnotation({
-      id: (0, _util.stringToPDFString)(file.filename),
-      filename: file.filename,
-      content: file.content
-    });
-    return _this22;
+    _this6 = _possibleConstructorReturn(this, _getPrototypeOf(FileAttachmentAnnotationElement).call(this, parameters, true));
+    var _this6$data$file = _this6.data.file,
+        filename = _this6$data$file.filename,
+        content = _this6$data$file.content;
+    _this6.filename = (0, _display_utils.getFilenameFromUrl)(filename);
+    _this6.content = content;
+
+    if (_this6.linkService.eventBus) {
+      _this6.linkService.eventBus.dispatch('fileattachmentannotation', {
+        source: _assertThisInitialized(_this6),
+        id: (0, _util.stringToPDFString)(filename),
+        filename: filename,
+        content: content
+      });
+    }
+
+    return _this6;
   }
 
   _createClass(FileAttachmentAnnotationElement, [{
-    key: 'render',
+    key: "render",
     value: function render() {
       this.container.className = 'fileAttachmentAnnotation';
       var trigger = document.createElement('div');
       trigger.style.height = this.container.style.height;
       trigger.style.width = this.container.style.width;
       trigger.addEventListener('dblclick', this._download.bind(this));
+
       if (!this.data.hasPopup && (this.data.title || this.data.contents)) {
         this._createPopup(this.container, trigger, this.data);
       }
+
       this.container.appendChild(trigger);
       return this.container;
     }
   }, {
-    key: '_download',
+    key: "_download",
     value: function _download() {
       if (!this.downloadManager) {
         (0, _util.warn)('Download cannot be started due to unavailable download manager');
         return;
       }
+
       this.downloadManager.downloadData(this.content, this.filename, '');
     }
   }]);
@@ -995,45 +1376,90 @@ var FileAttachmentAnnotationElement = function (_AnnotationElement14) {
   return FileAttachmentAnnotationElement;
 }(AnnotationElement);
 
-var AnnotationLayer = function () {
+var AnnotationLayer =
+/*#__PURE__*/
+function () {
   function AnnotationLayer() {
     _classCallCheck(this, AnnotationLayer);
   }
 
   _createClass(AnnotationLayer, null, [{
-    key: 'render',
+    key: "render",
     value: function render(parameters) {
-      for (var i = 0, ii = parameters.annotations.length; i < ii; i++) {
-        var data = parameters.annotations[i];
-        if (!data) {
-          continue;
+      var _iteratorNormalCompletion5 = true;
+      var _didIteratorError5 = false;
+      var _iteratorError5 = undefined;
+
+      try {
+        for (var _iterator5 = parameters.annotations[Symbol.iterator](), _step5; !(_iteratorNormalCompletion5 = (_step5 = _iterator5.next()).done); _iteratorNormalCompletion5 = true) {
+          var data = _step5.value;
+
+          if (!data) {
+            continue;
+          }
+
+          var element = AnnotationElementFactory.create({
+            data: data,
+            layer: parameters.div,
+            page: parameters.page,
+            viewport: parameters.viewport,
+            linkService: parameters.linkService,
+            downloadManager: parameters.downloadManager,
+            imageResourcesPath: parameters.imageResourcesPath || '',
+            renderInteractiveForms: parameters.renderInteractiveForms || false,
+            svgFactory: new _display_utils.DOMSVGFactory()
+          });
+
+          if (element.isRenderable) {
+            parameters.div.appendChild(element.render());
+          }
         }
-        var element = AnnotationElementFactory.create({
-          data: data,
-          layer: parameters.div,
-          page: parameters.page,
-          viewport: parameters.viewport,
-          linkService: parameters.linkService,
-          downloadManager: parameters.downloadManager,
-          imageResourcesPath: parameters.imageResourcesPath || '',
-          renderInteractiveForms: parameters.renderInteractiveForms || false,
-          svgFactory: new _dom_utils.DOMSVGFactory()
-        });
-        if (element.isRenderable) {
-          parameters.div.appendChild(element.render());
+      } catch (err) {
+        _didIteratorError5 = true;
+        _iteratorError5 = err;
+      } finally {
+        try {
+          if (!_iteratorNormalCompletion5 && _iterator5["return"] != null) {
+            _iterator5["return"]();
+          }
+        } finally {
+          if (_didIteratorError5) {
+            throw _iteratorError5;
+          }
         }
       }
     }
   }, {
-    key: 'update',
+    key: "update",
     value: function update(parameters) {
-      for (var i = 0, ii = parameters.annotations.length; i < ii; i++) {
-        var data = parameters.annotations[i];
-        var element = parameters.div.querySelector('[data-annotation-id="' + data.id + '"]');
-        if (element) {
-          element.style.transform = 'matrix(' + parameters.viewport.transform.join(',') + ')';
+      var _iteratorNormalCompletion6 = true;
+      var _didIteratorError6 = false;
+      var _iteratorError6 = undefined;
+
+      try {
+        for (var _iterator6 = parameters.annotations[Symbol.iterator](), _step6; !(_iteratorNormalCompletion6 = (_step6 = _iterator6.next()).done); _iteratorNormalCompletion6 = true) {
+          var data = _step6.value;
+          var element = parameters.div.querySelector("[data-annotation-id=\"".concat(data.id, "\"]"));
+
+          if (element) {
+            element.style.transform = "matrix(".concat(parameters.viewport.transform.join(','), ")");
+          }
+        }
+      } catch (err) {
+        _didIteratorError6 = true;
+        _iteratorError6 = err;
+      } finally {
+        try {
+          if (!_iteratorNormalCompletion6 && _iterator6["return"] != null) {
+            _iterator6["return"]();
+          }
+        } finally {
+          if (_didIteratorError6) {
+            throw _iteratorError6;
+          }
         }
       }
+
       parameters.div.removeAttribute('hidden');
     }
   }]);