pdfjs-dist 2.2.228 → 2.3.200

package/lib/core/annotation.js

@@ -24,6 +24,7 @@
 Object.defineProperty(exports, "__esModule", {
   value: true
 });
+exports.getQuadPoints = getQuadPoints;
 exports.MarkupAnnotation = exports.AnnotationFactory = exports.AnnotationBorderStyle = exports.Annotation = void 0;
 
 var _util = require("../shared/util");
@@ -56,6 +57,14 @@ function _inherits(subClass, superClass) { if (typeof superClass !== "function"
 
 function _setPrototypeOf(o, p) { _setPrototypeOf = Object.setPrototypeOf || function _setPrototypeOf(o, p) { o.__proto__ = p; return o; }; return _setPrototypeOf(o, p); }
 
+function _slicedToArray(arr, i) { return _arrayWithHoles(arr) || _iterableToArrayLimit(arr, i) || _nonIterableRest(); }
+
+function _nonIterableRest() { throw new TypeError("Invalid attempt to destructure non-iterable instance"); }
+
+function _iterableToArrayLimit(arr, i) { if (!(Symbol.iterator in Object(arr) || Object.prototype.toString.call(arr) === "[object Arguments]")) { return; } var _arr = []; var _n = true; var _d = false; var _e = undefined; try { for (var _i = arr[Symbol.iterator](), _s; !(_n = (_s = _i.next()).done); _n = true) { _arr.push(_s.value); if (i && _arr.length === i) break; } } catch (err) { _d = true; _e = err; } finally { try { if (!_n && _i["return"] != null) _i["return"](); } finally { if (_d) throw _e; } } return _arr; }
+
+function _arrayWithHoles(arr) { if (Array.isArray(arr)) return arr; }
+
 function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a 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); } }
@@ -184,13 +193,47 @@ function () {
 
 exports.AnnotationFactory = AnnotationFactory;
 
-function getTransformMatrix(rect, bbox, matrix) {
-  var bounds = _util.Util.getAxialAlignedBoundingBox(bbox, matrix);
+function getQuadPoints(dict, rect) {
+  if (!dict.has('QuadPoints')) {
+    return null;
+  }
+
+  var quadPoints = dict.getArray('QuadPoints');
+
+  if (!Array.isArray(quadPoints) || quadPoints.length % 8 > 0) {
+    return null;
+  }
+
+  var quadPointsLists = [];
+
+  for (var i = 0, ii = quadPoints.length / 8; i < ii; i++) {
+    quadPointsLists.push([]);
 
-  var minX = bounds[0];
-  var minY = bounds[1];
-  var maxX = bounds[2];
-  var maxY = bounds[3];
+    for (var j = i * 8, jj = i * 8 + 8; j < jj; j += 2) {
+      var x = quadPoints[j];
+      var y = quadPoints[j + 1];
+
+      if (x < rect[0] || x > rect[2] || y < rect[1] || y > rect[3]) {
+        return null;
+      }
+
+      quadPointsLists[i].push({
+        x: x,
+        y: y
+      });
+    }
+  }
+
+  return quadPointsLists;
+}
+
+function getTransformMatrix(rect, bbox, matrix) {
+  var _Util$getAxialAligned = _util.Util.getAxialAlignedBoundingBox(bbox, matrix),
+      _Util$getAxialAligned2 = _slicedToArray(_Util$getAxialAligned, 4),
+      minX = _Util$getAxialAligned2[0],
+      minY = _Util$getAxialAligned2[1],
+      maxX = _Util$getAxialAligned2[2],
+      maxY = _Util$getAxialAligned2[3];
 
   if (minX === maxX || minY === maxY) {
     return [1, 0, 0, 1, rect[0], rect[1]];
@@ -519,16 +562,34 @@ function () {
       if (Array.isArray(dashArray) && dashArray.length > 0) {
         var isValid = true;
         var allZeros = true;
-
-        for (var i = 0, len = dashArray.length; i < len; i++) {
-          var element = dashArray[i];
-          var validNumber = +element >= 0;
-
-          if (!validNumber) {
-            isValid = false;
-            break;
-          } else if (element > 0) {
-            allZeros = false;
+        var _iteratorNormalCompletion = true;
+        var _didIteratorError = false;
+        var _iteratorError = undefined;
+
+        try {
+          for (var _iterator = dashArray[Symbol.iterator](), _step; !(_iteratorNormalCompletion = (_step = _iterator.next()).done); _iteratorNormalCompletion = true) {
+            var element = _step.value;
+            var validNumber = +element >= 0;
+
+            if (!validNumber) {
+              isValid = false;
+              break;
+            } else if (element > 0) {
+              allZeros = false;
+            }
+          }
+        } catch (err) {
+          _didIteratorError = true;
+          _iteratorError = err;
+        } finally {
+          try {
+            if (!_iteratorNormalCompletion && _iterator["return"] != null) {
+              _iterator["return"]();
+            }
+          } finally {
+            if (_didIteratorError) {
+              throw _iteratorError;
+            }
           }
         }
 
@@ -575,15 +636,59 @@ function (_Annotation) {
     _this2 = _possibleConstructorReturn(this, _getPrototypeOf(MarkupAnnotation).call(this, parameters));
     var dict = parameters.dict;
 
-    if (!dict.has('C')) {
-      _this2.data.color = null;
+    if (dict.has('IRT')) {
+      var rawIRT = dict.getRaw('IRT');
+      _this2.data.inReplyTo = (0, _primitives.isRef)(rawIRT) ? rawIRT.toString() : null;
+      var rt = dict.get('RT');
+      _this2.data.replyType = (0, _primitives.isName)(rt) ? rt.name : _util.AnnotationReplyType.REPLY;
     }
 
-    _this2.setCreationDate(dict.get('CreationDate'));
+    if (_this2.data.replyType === _util.AnnotationReplyType.GROUP) {
+      var parent = dict.get('IRT');
+      _this2.data.title = (0, _util.stringToPDFString)(parent.get('T') || '');
+
+      _this2.setContents(parent.get('Contents'));
+
+      _this2.data.contents = _this2.contents;
+
+      if (!parent.has('CreationDate')) {
+        _this2.data.creationDate = null;
+      } else {
+        _this2.setCreationDate(parent.get('CreationDate'));
+
+        _this2.data.creationDate = _this2.creationDate;
+      }
+
+      if (!parent.has('M')) {
+        _this2.data.modificationDate = null;
+      } else {
+        _this2.setModificationDate(parent.get('M'));
+
+        _this2.data.modificationDate = _this2.modificationDate;
+      }
+
+      _this2.data.hasPopup = parent.has('Popup');
+
+      if (!parent.has('C')) {
+        _this2.data.color = null;
+      } else {
+        _this2.setColor(parent.getArray('C'));
+
+        _this2.data.color = _this2.color;
+      }
+    } else {
+      _this2.data.title = (0, _util.stringToPDFString)(dict.get('T') || '');
+
+      _this2.setCreationDate(dict.get('CreationDate'));
+
+      _this2.data.creationDate = _this2.creationDate;
+      _this2.data.hasPopup = dict.has('Popup');
+
+      if (!dict.has('C')) {
+        _this2.data.color = null;
+      }
+    }
 
-    _this2.data.creationDate = _this2.creationDate;
-    _this2.data.hasPopup = dict.has('Popup');
-    _this2.data.title = (0, _util.stringToPDFString)(dict.get('T') || '');
     return _this2;
   }
 
@@ -854,12 +959,31 @@ function (_WidgetAnnotation2) {
         return;
       }
 
-      var keys = normalAppearanceState.getKeys();
+      var _iteratorNormalCompletion2 = true;
+      var _didIteratorError2 = false;
+      var _iteratorError2 = undefined;
 
-      for (var i = 0, ii = keys.length; i < ii; i++) {
-        if (keys[i] !== 'Off') {
-          this.data.buttonValue = keys[i];
-          break;
+      try {
+        for (var _iterator2 = normalAppearanceState.getKeys()[Symbol.iterator](), _step2; !(_iteratorNormalCompletion2 = (_step2 = _iterator2.next()).done); _iteratorNormalCompletion2 = true) {
+          var key = _step2.value;
+
+          if (key !== 'Off') {
+            this.data.buttonValue = key;
+            break;
+          }
+        }
+      } catch (err) {
+        _didIteratorError2 = true;
+        _iteratorError2 = err;
+      } finally {
+        try {
+          if (!_iteratorNormalCompletion2 && _iterator2["return"] != null) {
+            _iterator2["return"]();
+          }
+        } finally {
+          if (_didIteratorError2) {
+            throw _iteratorError2;
+          }
         }
       }
     }
@@ -936,6 +1060,7 @@ function (_MarkupAnnotation) {
 
     var DEFAULT_ICON_SIZE = 22;
     _this7 = _possibleConstructorReturn(this, _getPrototypeOf(TextAnnotation).call(this, parameters));
+    var dict = parameters.dict;
     _this7.data.annotationType = _util.AnnotationType.TEXT;
 
     if (_this7.data.hasAppearance) {
@@ -943,7 +1068,15 @@ function (_MarkupAnnotation) {
     } else {
       _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';
+      _this7.data.name = dict.has('Name') ? dict.get('Name').name : 'Note';
+    }
+
+    if (dict.has('State')) {
+      _this7.data.state = dict.get('State') || null;
+      _this7.data.stateModel = dict.get('StateModel') || null;
+    } else {
+      _this7.data.state = null;
+      _this7.data.stateModel = null;
     }
 
     return _this7;
@@ -964,6 +1097,11 @@ function (_Annotation3) {
 
     _this8 = _possibleConstructorReturn(this, _getPrototypeOf(LinkAnnotation).call(this, params));
     _this8.data.annotationType = _util.AnnotationType.LINK;
+    var quadPoints = getQuadPoints(params.dict, _this8.rectangle);
+
+    if (quadPoints) {
+      _this8.data.quadPoints = quadPoints;
+    }
 
     _obj.Catalog.parseDestDictionary({
       destDict: params.dict,
@@ -989,8 +1127,7 @@ function (_Annotation4) {
 
     _this9 = _possibleConstructorReturn(this, _getPrototypeOf(PopupAnnotation).call(this, parameters));
     _this9.data.annotationType = _util.AnnotationType.POPUP;
-    var dict = parameters.dict;
-    var parentItem = dict.get('Parent');
+    var parentItem = parameters.dict.get('Parent');
 
     if (!parentItem) {
       (0, _util.warn)('Popup annotation has a missing or invalid parent annotation.');
@@ -999,9 +1136,13 @@ function (_Annotation4) {
 
     var parentSubtype = parentItem.get('Subtype');
     _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') || '');
+    var rawParent = parameters.dict.getRaw('Parent');
+    _this9.data.parentId = (0, _primitives.isRef)(rawParent) ? rawParent.toString() : null;
+    var rt = parentItem.get('RT');
+
+    if ((0, _primitives.isName)(rt, _util.AnnotationReplyType.GROUP)) {
+      parentItem = parentItem.get('IRT');
+    }
 
     if (!parentItem.has('M')) {
       _this9.data.modificationDate = null;
@@ -1027,6 +1168,8 @@ function (_Annotation4) {
       }
     }
 
+    _this9.data.title = (0, _util.stringToPDFString)(parentItem.get('T') || '');
+    _this9.data.contents = (0, _util.stringToPDFString)(parentItem.get('Contents') || '');
     return _this9;
   }
 
@@ -1063,8 +1206,7 @@ function (_MarkupAnnotation3) {
 
     _this11 = _possibleConstructorReturn(this, _getPrototypeOf(LineAnnotation).call(this, parameters));
     _this11.data.annotationType = _util.AnnotationType.LINE;
-    var dict = parameters.dict;
-    _this11.data.lineCoordinates = _util.Util.normalizeRect(dict.getArray('L'));
+    _this11.data.lineCoordinates = _util.Util.normalizeRect(parameters.dict.getArray('L'));
     return _this11;
   }
 
@@ -1119,8 +1261,7 @@ function (_MarkupAnnotation6) {
 
     _this14 = _possibleConstructorReturn(this, _getPrototypeOf(PolylineAnnotation).call(this, parameters));
     _this14.data.annotationType = _util.AnnotationType.POLYLINE;
-    var dict = parameters.dict;
-    var rawVertices = dict.getArray('Vertices');
+    var rawVertices = parameters.dict.getArray('Vertices');
     _this14.data.vertices = [];
 
     for (var i = 0, ii = rawVertices.length; i < ii; i += 2) {
@@ -1184,9 +1325,8 @@ function (_MarkupAnnotation8) {
 
     _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');
+    var originalInkLists = parameters.dict.getArray('InkList');
     _this17.data.inkLists = [];
 
     for (var i = 0, ii = originalInkLists.length; i < ii; ++i) {
@@ -1218,6 +1358,12 @@ function (_MarkupAnnotation9) {
 
     _this18 = _possibleConstructorReturn(this, _getPrototypeOf(HighlightAnnotation).call(this, parameters));
     _this18.data.annotationType = _util.AnnotationType.HIGHLIGHT;
+    var quadPoints = getQuadPoints(parameters.dict, _this18.rectangle);
+
+    if (quadPoints) {
+      _this18.data.quadPoints = quadPoints;
+    }
+
     return _this18;
   }
 
@@ -1236,6 +1382,12 @@ function (_MarkupAnnotation10) {
 
     _this19 = _possibleConstructorReturn(this, _getPrototypeOf(UnderlineAnnotation).call(this, parameters));
     _this19.data.annotationType = _util.AnnotationType.UNDERLINE;
+    var quadPoints = getQuadPoints(parameters.dict, _this19.rectangle);
+
+    if (quadPoints) {
+      _this19.data.quadPoints = quadPoints;
+    }
+
     return _this19;
   }
 
@@ -1254,6 +1406,12 @@ function (_MarkupAnnotation11) {
 
     _this20 = _possibleConstructorReturn(this, _getPrototypeOf(SquigglyAnnotation).call(this, parameters));
     _this20.data.annotationType = _util.AnnotationType.SQUIGGLY;
+    var quadPoints = getQuadPoints(parameters.dict, _this20.rectangle);
+
+    if (quadPoints) {
+      _this20.data.quadPoints = quadPoints;
+    }
+
     return _this20;
   }
 
@@ -1272,6 +1430,12 @@ function (_MarkupAnnotation12) {
 
     _this21 = _possibleConstructorReturn(this, _getPrototypeOf(StrikeOutAnnotation).call(this, parameters));
     _this21.data.annotationType = _util.AnnotationType.STRIKEOUT;
+    var quadPoints = getQuadPoints(parameters.dict, _this21.rectangle);
+
+    if (quadPoints) {
+      _this21.data.quadPoints = quadPoints;
+    }
+
     return _this21;
   }
 

package/lib/core/chunked_stream.js

@@ -190,7 +190,10 @@ function () {
         return -1;
       }
 
-      this.ensureByte(pos);
+      if (pos >= this.progressiveDataLength) {
+        this.ensureByte(pos);
+      }
+
       return this.bytes[this.pos++];
     }
   }, {
@@ -223,7 +226,9 @@ function () {
       var strEnd = this.end;
 
       if (!length) {
-        this.ensureRange(pos, strEnd);
+        if (strEnd > this.progressiveDataLength) {
+          this.ensureRange(pos, strEnd);
+        }
 
         var _subarray = bytes.subarray(pos, strEnd);
 
@@ -236,7 +241,10 @@ function () {
         end = strEnd;
       }
 
-      this.ensureRange(pos, end);
+      if (end > this.progressiveDataLength) {
+        this.ensureRange(pos, end);
+      }
+
       this.pos = end;
       var subarray = bytes.subarray(pos, end);
       return forceClamped ? new Uint8ClampedArray(subarray) : subarray;
@@ -259,7 +267,18 @@ function () {
   }, {
     key: "getByteRange",
     value: function getByteRange(begin, end) {
-      this.ensureRange(begin, end);
+      if (begin < 0) {
+        begin = 0;
+      }
+
+      if (end > this.end) {
+        end = this.end;
+      }
+
+      if (end > this.progressiveDataLength) {
+        this.ensureRange(begin, end);
+      }
+
       return this.bytes.subarray(begin, end);
     }
   }, {
@@ -285,9 +304,13 @@ function () {
     key: "makeSubStream",
     value: function makeSubStream(start, length, dict) {
       if (length) {
-        this.ensureRange(start, start + length);
+        if (start + length > this.progressiveDataLength) {
+          this.ensureRange(start, start + length);
+        }
       } else {
-        this.ensureByte(start);
+        if (start >= this.progressiveDataLength) {
+          this.ensureByte(start);
+        }
       }
 
       function ChunkedStreamSubstream() {}
@@ -714,15 +737,15 @@ function () {
     }
   }, {
     key: "abort",
-    value: function abort() {
+    value: function abort(reason) {
       this.aborted = true;
 
       if (this.pdfNetworkStream) {
-        this.pdfNetworkStream.cancelAllRequests('abort');
+        this.pdfNetworkStream.cancelAllRequests(reason);
       }
 
       for (var requestId in this.promisesByRequest) {
-        this.promisesByRequest[requestId].reject(new Error('Request was aborted'));
+        this.promisesByRequest[requestId].reject(reason);
       }
     }
   }]);

package/lib/core/core_utils.js

@@ -31,6 +31,20 @@ exports.XRefParseException = exports.XRefEntryException = exports.MissingDataExc
 
 var _util = require("../shared/util");
 
+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 _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }
+
+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 getLookupTableFactory(initializer) {
   var lookup;
   return function () {
@@ -44,44 +58,56 @@ function getLookupTableFactory(initializer) {
   };
 }
 
-var MissingDataException = function MissingDataExceptionClosure() {
+var MissingDataException =
+/*#__PURE__*/
+function (_BaseException) {
+  _inherits(MissingDataException, _BaseException);
+
   function MissingDataException(begin, end) {
-    this.begin = begin;
-    this.end = end;
-    this.message = "Missing data [".concat(begin, ", ").concat(end, ")");
+    var _this;
+
+    _classCallCheck(this, MissingDataException);
+
+    _this = _possibleConstructorReturn(this, _getPrototypeOf(MissingDataException).call(this, "Missing data [".concat(begin, ", ").concat(end, ")")));
+    _this.begin = begin;
+    _this.end = end;
+    return _this;
   }
 
-  MissingDataException.prototype = new Error();
-  MissingDataException.prototype.name = 'MissingDataException';
-  MissingDataException.constructor = MissingDataException;
   return MissingDataException;
-}();
+}(_util.BaseException);
 
 exports.MissingDataException = MissingDataException;
 
-var XRefEntryException = function XRefEntryExceptionClosure() {
-  function XRefEntryException(msg) {
-    this.message = msg;
+var XRefEntryException =
+/*#__PURE__*/
+function (_BaseException2) {
+  _inherits(XRefEntryException, _BaseException2);
+
+  function XRefEntryException() {
+    _classCallCheck(this, XRefEntryException);
+
+    return _possibleConstructorReturn(this, _getPrototypeOf(XRefEntryException).apply(this, arguments));
   }
 
-  XRefEntryException.prototype = new Error();
-  XRefEntryException.prototype.name = 'XRefEntryException';
-  XRefEntryException.constructor = XRefEntryException;
   return XRefEntryException;
-}();
+}(_util.BaseException);
 
 exports.XRefEntryException = XRefEntryException;
 
-var XRefParseException = function XRefParseExceptionClosure() {
-  function XRefParseException(msg) {
-    this.message = msg;
+var XRefParseException =
+/*#__PURE__*/
+function (_BaseException3) {
+  _inherits(XRefParseException, _BaseException3);
+
+  function XRefParseException() {
+    _classCallCheck(this, XRefParseException);
+
+    return _possibleConstructorReturn(this, _getPrototypeOf(XRefParseException).apply(this, arguments));
   }
 
-  XRefParseException.prototype = new Error();
-  XRefParseException.prototype.name = 'XRefParseException';
-  XRefParseException.constructor = XRefParseException;
   return XRefParseException;
-}();
+}(_util.BaseException);
 
 exports.XRefParseException = XRefParseException;