pdfjs-dist 2.0.489 → 2.2.228

package/lib/web/overlay_manager.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,17 +19,30 @@
  * @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.OverlayManager = void 0;
 
-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 _regenerator = _interopRequireDefault(require("@babel/runtime/regenerator"));
+
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { "default": obj }; }
+
+function asyncGeneratorStep(gen, resolve, reject, _next, _throw, key, arg) { try { var info = gen[key](arg); var value = info.value; } catch (error) { reject(error); return; } if (info.done) { resolve(value); } else { Promise.resolve(value).then(_next, _throw); } }
+
+function _asyncToGenerator(fn) { return function () { var self = this, args = arguments; return new Promise(function (resolve, reject) { var gen = fn.apply(self, args); function _next(value) { asyncGeneratorStep(gen, resolve, reject, _next, _throw, "next", value); } function _throw(err) { asyncGeneratorStep(gen, resolve, reject, _next, _throw, "throw", err); } _next(undefined); }); }; }
 
 function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }
 
-var OverlayManager = 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 OverlayManager =
+/*#__PURE__*/
+function () {
   function OverlayManager() {
     _classCallCheck(this, OverlayManager);
 
@@ -39,108 +52,245 @@ var OverlayManager = function () {
   }
 
   _createClass(OverlayManager, [{
-    key: 'register',
-    value: function register(name, element) {
-      var _this = this;
-
-      var callerCloseMethod = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : null;
-      var canForceClose = arguments.length > 3 && arguments[3] !== undefined ? arguments[3] : false;
-
-      return new Promise(function (resolve) {
-        var container = void 0;
-        if (!name || !element || !(container = element.parentNode)) {
-          throw new Error('Not enough parameters.');
-        } else if (_this._overlays[name]) {
-          throw new Error('The overlay is already registered.');
-        }
-        _this._overlays[name] = {
-          element: element,
-          container: container,
-          callerCloseMethod: callerCloseMethod,
-          canForceClose: canForceClose
-        };
-        resolve();
-      });
-    }
+    key: "register",
+    value: function () {
+      var _register = _asyncToGenerator(
+      /*#__PURE__*/
+      _regenerator["default"].mark(function _callee(name, element) {
+        var callerCloseMethod,
+            canForceClose,
+            container,
+            _args = arguments;
+        return _regenerator["default"].wrap(function _callee$(_context) {
+          while (1) {
+            switch (_context.prev = _context.next) {
+              case 0:
+                callerCloseMethod = _args.length > 2 && _args[2] !== undefined ? _args[2] : null;
+                canForceClose = _args.length > 3 && _args[3] !== undefined ? _args[3] : false;
+
+                if (!(!name || !element || !(container = element.parentNode))) {
+                  _context.next = 6;
+                  break;
+                }
+
+                throw new Error('Not enough parameters.');
+
+              case 6:
+                if (!this._overlays[name]) {
+                  _context.next = 8;
+                  break;
+                }
+
+                throw new Error('The overlay is already registered.');
+
+              case 8:
+                this._overlays[name] = {
+                  element: element,
+                  container: container,
+                  callerCloseMethod: callerCloseMethod,
+                  canForceClose: canForceClose
+                };
+
+              case 9:
+              case "end":
+                return _context.stop();
+            }
+          }
+        }, _callee, this);
+      }));
+
+      function register(_x, _x2) {
+        return _register.apply(this, arguments);
+      }
+
+      return register;
+    }()
   }, {
-    key: 'unregister',
-    value: function unregister(name) {
-      var _this2 = this;
-
-      return new Promise(function (resolve) {
-        if (!_this2._overlays[name]) {
-          throw new Error('The overlay does not exist.');
-        } else if (_this2._active === name) {
-          throw new Error('The overlay cannot be removed while it is active.');
-        }
-        delete _this2._overlays[name];
-        resolve();
-      });
-    }
+    key: "unregister",
+    value: function () {
+      var _unregister = _asyncToGenerator(
+      /*#__PURE__*/
+      _regenerator["default"].mark(function _callee2(name) {
+        return _regenerator["default"].wrap(function _callee2$(_context2) {
+          while (1) {
+            switch (_context2.prev = _context2.next) {
+              case 0:
+                if (this._overlays[name]) {
+                  _context2.next = 4;
+                  break;
+                }
+
+                throw new Error('The overlay does not exist.');
+
+              case 4:
+                if (!(this._active === name)) {
+                  _context2.next = 6;
+                  break;
+                }
+
+                throw new Error('The overlay cannot be removed while it is active.');
+
+              case 6:
+                delete this._overlays[name];
+
+              case 7:
+              case "end":
+                return _context2.stop();
+            }
+          }
+        }, _callee2, this);
+      }));
+
+      function unregister(_x3) {
+        return _unregister.apply(this, arguments);
+      }
+
+      return unregister;
+    }()
   }, {
-    key: 'open',
-    value: function open(name) {
-      var _this3 = this;
-
-      return new Promise(function (resolve) {
-        if (!_this3._overlays[name]) {
-          throw new Error('The overlay does not exist.');
-        } else if (_this3._active) {
-          if (_this3._overlays[name].canForceClose) {
-            _this3._closeThroughCaller();
-          } else if (_this3._active === name) {
-            throw new Error('The overlay is already active.');
-          } else {
-            throw new Error('Another overlay is currently active.');
+    key: "open",
+    value: function () {
+      var _open = _asyncToGenerator(
+      /*#__PURE__*/
+      _regenerator["default"].mark(function _callee3(name) {
+        return _regenerator["default"].wrap(function _callee3$(_context3) {
+          while (1) {
+            switch (_context3.prev = _context3.next) {
+              case 0:
+                if (this._overlays[name]) {
+                  _context3.next = 4;
+                  break;
+                }
+
+                throw new Error('The overlay does not exist.');
+
+              case 4:
+                if (!this._active) {
+                  _context3.next = 14;
+                  break;
+                }
+
+                if (!this._overlays[name].canForceClose) {
+                  _context3.next = 9;
+                  break;
+                }
+
+                this._closeThroughCaller();
+
+                _context3.next = 14;
+                break;
+
+              case 9:
+                if (!(this._active === name)) {
+                  _context3.next = 13;
+                  break;
+                }
+
+                throw new Error('The overlay is already active.');
+
+              case 13:
+                throw new Error('Another overlay is currently active.');
+
+              case 14:
+                this._active = name;
+
+                this._overlays[this._active].element.classList.remove('hidden');
+
+                this._overlays[this._active].container.classList.remove('hidden');
+
+                window.addEventListener('keydown', this._keyDownBound);
+
+              case 18:
+              case "end":
+                return _context3.stop();
+            }
           }
-        }
-        _this3._active = name;
-        _this3._overlays[_this3._active].element.classList.remove('hidden');
-        _this3._overlays[_this3._active].container.classList.remove('hidden');
-        window.addEventListener('keydown', _this3._keyDownBound);
-        resolve();
-      });
-    }
+        }, _callee3, this);
+      }));
+
+      function open(_x4) {
+        return _open.apply(this, arguments);
+      }
+
+      return open;
+    }()
   }, {
-    key: 'close',
-    value: function close(name) {
-      var _this4 = this;
-
-      return new Promise(function (resolve) {
-        if (!_this4._overlays[name]) {
-          throw new Error('The overlay does not exist.');
-        } else if (!_this4._active) {
-          throw new Error('The overlay is currently not active.');
-        } else if (_this4._active !== name) {
-          throw new Error('Another overlay is currently active.');
-        }
-        _this4._overlays[_this4._active].container.classList.add('hidden');
-        _this4._overlays[_this4._active].element.classList.add('hidden');
-        _this4._active = null;
-        window.removeEventListener('keydown', _this4._keyDownBound);
-        resolve();
-      });
-    }
+    key: "close",
+    value: function () {
+      var _close = _asyncToGenerator(
+      /*#__PURE__*/
+      _regenerator["default"].mark(function _callee4(name) {
+        return _regenerator["default"].wrap(function _callee4$(_context4) {
+          while (1) {
+            switch (_context4.prev = _context4.next) {
+              case 0:
+                if (this._overlays[name]) {
+                  _context4.next = 4;
+                  break;
+                }
+
+                throw new Error('The overlay does not exist.');
+
+              case 4:
+                if (this._active) {
+                  _context4.next = 8;
+                  break;
+                }
+
+                throw new Error('The overlay is currently not active.');
+
+              case 8:
+                if (!(this._active !== name)) {
+                  _context4.next = 10;
+                  break;
+                }
+
+                throw new Error('Another overlay is currently active.');
+
+              case 10:
+                this._overlays[this._active].container.classList.add('hidden');
+
+                this._overlays[this._active].element.classList.add('hidden');
+
+                this._active = null;
+                window.removeEventListener('keydown', this._keyDownBound);
+
+              case 14:
+              case "end":
+                return _context4.stop();
+            }
+          }
+        }, _callee4, this);
+      }));
+
+      function close(_x5) {
+        return _close.apply(this, arguments);
+      }
+
+      return close;
+    }()
   }, {
-    key: '_keyDown',
+    key: "_keyDown",
     value: function _keyDown(evt) {
       if (this._active && evt.keyCode === 27) {
         this._closeThroughCaller();
+
         evt.preventDefault();
       }
     }
   }, {
-    key: '_closeThroughCaller',
+    key: "_closeThroughCaller",
     value: function _closeThroughCaller() {
       if (this._overlays[this._active].callerCloseMethod) {
         this._overlays[this._active].callerCloseMethod();
       }
+
       if (this._active) {
         this.close(this._active);
       }
     }
   }, {
-    key: 'active',
+    key: "active",
     get: function get() {
       return this._active;
     }

package/lib/web/password_prompt.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,22 +19,26 @@
  * @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.PasswordPrompt = undefined;
+exports.PasswordPrompt = void 0;
 
-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 _ui_utils = require("./ui_utils");
 
-var _ui_utils = require('./ui_utils');
-
-var _pdf = require('../pdf');
+var _pdf = require("../pdf");
 
 function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }
 
-var PasswordPrompt = 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 PasswordPrompt =
+/*#__PURE__*/
+function () {
   function PasswordPrompt(options, overlayManager) {
     var _this = this;
 
@@ -63,25 +67,28 @@ var PasswordPrompt = function () {
   }
 
   _createClass(PasswordPrompt, [{
-    key: 'open',
+    key: "open",
     value: function open() {
       var _this2 = this;
 
       this.overlayManager.open(this.overlayName).then(function () {
         _this2.input.focus();
-        var promptString = void 0;
+
+        var promptString;
+
         if (_this2.reason === _pdf.PasswordResponses.INCORRECT_PASSWORD) {
           promptString = _this2.l10n.get('password_invalid', null, 'Invalid password. Please try again.');
         } else {
           promptString = _this2.l10n.get('password_label', null, 'Enter the password to open this PDF file.');
         }
+
         promptString.then(function (msg) {
           _this2.label.textContent = msg;
         });
       });
     }
   }, {
-    key: 'close',
+    key: "close",
     value: function close() {
       var _this3 = this;
 
@@ -90,16 +97,17 @@ var PasswordPrompt = function () {
       });
     }
   }, {
-    key: 'verify',
+    key: "verify",
     value: function verify() {
       var password = this.input.value;
+
       if (password && password.length > 0) {
         this.close();
-        return this.updateCallback(password);
+        this.updateCallback(password);
       }
     }
   }, {
-    key: 'setUpdateCallback',
+    key: "setUpdateCallback",
     value: function setUpdateCallback(updateCallback, reason) {
       this.updateCallback = updateCallback;
       this.reason = reason;

package/lib/web/pdf_attachment_viewer.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,20 +19,24 @@
  * @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.PDFAttachmentViewer = undefined;
+exports.PDFAttachmentViewer = void 0;
 
-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 _pdf = require('../pdf');
+var _pdf = require("../pdf");
 
 function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }
 
-var PDFAttachmentViewer = 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 PDFAttachmentViewer =
+/*#__PURE__*/
+function () {
   function PDFAttachmentViewer(_ref) {
     var container = _ref.container,
         eventBus = _ref.eventBus,
@@ -48,72 +52,82 @@ var PDFAttachmentViewer = function () {
   }
 
   _createClass(PDFAttachmentViewer, [{
-    key: 'reset',
+    key: "reset",
     value: function reset() {
       var keepRenderedCapability = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : false;
-
       this.attachments = null;
       this.container.textContent = '';
+
       if (!keepRenderedCapability) {
         this._renderedCapability = (0, _pdf.createPromiseCapability)();
       }
     }
   }, {
-    key: '_dispatchEvent',
+    key: "_dispatchEvent",
     value: function _dispatchEvent(attachmentsCount) {
       this._renderedCapability.resolve();
+
       this.eventBus.dispatch('attachmentsloaded', {
         source: this,
         attachmentsCount: attachmentsCount
       });
     }
   }, {
-    key: '_bindPdfLink',
+    key: "_bindPdfLink",
     value: function _bindPdfLink(button, content, filename) {
       if (this.downloadManager.disableCreateObjectURL) {
         throw new Error('bindPdfLink: Unsupported "disableCreateObjectURL" value.');
       }
-      var blobUrl = void 0;
+
+      var blobUrl;
+
       button.onclick = function () {
         if (!blobUrl) {
           blobUrl = (0, _pdf.createObjectURL)(content, 'application/pdf');
         }
-        var viewerUrl = void 0;
+
+        var viewerUrl;
         viewerUrl = '?file=' + encodeURIComponent(blobUrl + '#' + filename);
         window.open(viewerUrl);
         return false;
       };
     }
   }, {
-    key: '_bindLink',
+    key: "_bindLink",
     value: function _bindLink(button, content, filename) {
       var _this = this;
 
       button.onclick = function () {
         _this.downloadManager.downloadData(content, filename, '');
+
         return false;
       };
     }
   }, {
-    key: 'render',
+    key: "render",
     value: function render(_ref2) {
       var attachments = _ref2.attachments,
           _ref2$keepRenderedCap = _ref2.keepRenderedCapability,
-          keepRenderedCapability = _ref2$keepRenderedCap === undefined ? false : _ref2$keepRenderedCap;
-
+          keepRenderedCapability = _ref2$keepRenderedCap === void 0 ? false : _ref2$keepRenderedCap;
       var attachmentsCount = 0;
+
       if (this.attachments) {
         this.reset(keepRenderedCapability === true);
       }
+
       this.attachments = attachments || null;
+
       if (!attachments) {
         this._dispatchEvent(attachmentsCount);
+
         return;
       }
+
       var names = Object.keys(attachments).sort(function (a, b) {
         return a.toLowerCase().localeCompare(b.toLowerCase());
       });
       attachmentsCount = names.length;
+
       for (var i = 0; i < attachmentsCount; i++) {
         var item = attachments[names[i]];
         var filename = (0, _pdf.removeNullCharacters)((0, _pdf.getFilenameFromUrl)(item.filename));
@@ -121,18 +135,21 @@ var PDFAttachmentViewer = function () {
         div.className = 'attachmentsItem';
         var button = document.createElement('button');
         button.textContent = filename;
+
         if (/\.pdf$/i.test(filename) && !this.downloadManager.disableCreateObjectURL) {
           this._bindPdfLink(button, item.content, filename);
         } else {
           this._bindLink(button, item.content, filename);
         }
+
         div.appendChild(button);
         this.container.appendChild(div);
       }
+
       this._dispatchEvent(attachmentsCount);
     }
   }, {
-    key: '_appendAttachment',
+    key: "_appendAttachment",
     value: function _appendAttachment(_ref3) {
       var _this2 = this;
 
@@ -142,6 +159,7 @@ var PDFAttachmentViewer = function () {
 
       this._renderedCapability.promise.then(function () {
         var attachments = _this2.attachments;
+
         if (!attachments) {
           attachments = Object.create(null);
         } else {
@@ -151,10 +169,12 @@ var PDFAttachmentViewer = function () {
             }
           }
         }
+
         attachments[id] = {
           filename: filename,
           content: content
         };
+
         _this2.render({
           attachments: attachments,
           keepRenderedCapability: true