pdfjs-dist 2.0.550 → 2.3.200

package/lib/shared/global_scope.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,6 +19,6 @@
  * @licend The above is the entire license notice for the
  * Javascript code in this page
  */
-'use strict';
+"use strict";
 
 module.exports = typeof window !== 'undefined' && window.Math === Math ? window : typeof global !== 'undefined' && global.Math === Math ? global : typeof self !== 'undefined' && self.Math === Math ? self : {};

package/lib/shared/is_node.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,10 +19,10 @@
  * @licend The above is the entire license notice for the
  * Javascript code in this page
  */
-'use strict';
+"use strict";
 
-var _typeof = typeof Symbol === "function" && typeof Symbol.iterator === "symbol" ? function (obj) { return typeof obj; } : function (obj) { return obj && typeof Symbol === "function" && obj.constructor === Symbol && obj !== Symbol.prototype ? "symbol" : typeof obj; };
+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); }
 
 module.exports = function isNodeJS() {
-  return (typeof process === 'undefined' ? 'undefined' : _typeof(process)) === 'object' && process + '' === '[object process]';
+  return (typeof process === "undefined" ? "undefined" : _typeof(process)) === 'object' && process + '' === '[object process]' && !process.versions['nw'] && !process.versions['electron'];
 };

package/lib/shared/message_handler.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,58 +19,52 @@
  * @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.MessageHandler = undefined;
+exports.MessageHandler = MessageHandler;
 
-var _typeof = typeof Symbol === "function" && typeof Symbol.iterator === "symbol" ? function (obj) { return typeof obj; } : function (obj) { return obj && typeof Symbol === "function" && obj.constructor === Symbol && obj !== Symbol.prototype ? "symbol" : typeof obj; };
+var _util = require("./util");
 
-var _util = require('./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 resolveCall(fn, args) {
-  var thisArg = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : null;
+var StreamKind = {
+  UNKNOWN: 0,
+  CANCEL: 1,
+  CANCEL_COMPLETE: 2,
+  CLOSE: 3,
+  ENQUEUE: 4,
+  ERROR: 5,
+  PULL: 6,
+  PULL_COMPLETE: 7,
+  START_COMPLETE: 8
+};
 
-  if (!fn) {
-    return Promise.resolve(undefined);
-  }
-  return new Promise(function (resolve, reject) {
-    resolve(fn.apply(thisArg, args));
-  });
-}
 function wrapReason(reason) {
-  if ((typeof reason === 'undefined' ? 'undefined' : _typeof(reason)) !== 'object') {
+  if (_typeof(reason) !== 'object') {
     return reason;
   }
+
   switch (reason.name) {
     case 'AbortException':
       return new _util.AbortException(reason.message);
+
     case 'MissingPDFException':
       return new _util.MissingPDFException(reason.message);
+
     case 'UnexpectedResponseException':
       return new _util.UnexpectedResponseException(reason.message, reason.status);
-    default:
+
+    case 'UnknownErrorException':
       return new _util.UnknownErrorException(reason.message, reason.details);
+
+    default:
+      return new _util.UnknownErrorException(reason.message, reason.toString());
   }
 }
-function makeReasonSerializable(reason) {
-  if (!(reason instanceof Error) || reason instanceof _util.AbortException || reason instanceof _util.MissingPDFException || reason instanceof _util.UnexpectedResponseException || reason instanceof _util.UnknownErrorException) {
-    return reason;
-  }
-  return new _util.UnknownErrorException(reason.message, reason.toString());
-}
-function resolveOrReject(capability, success, reason) {
-  if (success) {
-    capability.resolve();
-  } else {
-    capability.reject(reason);
-  }
-}
-function finalize(promise) {
-  return Promise.resolve(promise).catch(function () {});
-}
+
 function MessageHandler(sourceName, targetName, comObj) {
   var _this = this;
 
@@ -84,33 +78,39 @@ function MessageHandler(sourceName, targetName, comObj) {
   this.streamControllers = Object.create(null);
   var callbacksCapabilities = this.callbacksCapabilities = Object.create(null);
   var ah = this.actionHandler = Object.create(null);
+
   this._onComObjOnMessage = function (event) {
     var data = event.data;
+
     if (data.targetName !== _this.sourceName) {
       return;
     }
+
     if (data.stream) {
       _this._processStreamMessage(data);
     } else if (data.isReply) {
       var callbackId = data.callbackId;
+
       if (data.callbackId in callbacksCapabilities) {
         var callback = callbacksCapabilities[callbackId];
         delete callbacksCapabilities[callbackId];
-        if ('error' in data) {
-          callback.reject(wrapReason(data.error));
+
+        if ('reason' in data) {
+          callback.reject(wrapReason(data.reason));
         } else {
           callback.resolve(data.data);
         }
       } else {
-        throw new Error('Cannot resolve callback ' + callbackId);
+        throw new Error("Cannot resolve callback ".concat(callbackId));
       }
     } else if (data.action in ah) {
       var action = ah[data.action];
+
       if (data.callbackId) {
         var _sourceName = _this.sourceName;
         var _targetName = data.sourceName;
-        Promise.resolve().then(function () {
-          return action[0].call(action[1], data.data);
+        new Promise(function (resolve) {
+          resolve(action(data.data));
         }).then(function (result) {
           comObj.postMessage({
             sourceName: _sourceName,
@@ -125,53 +125,57 @@ function MessageHandler(sourceName, targetName, comObj) {
             targetName: _targetName,
             isReply: true,
             callbackId: data.callbackId,
-            error: makeReasonSerializable(reason)
+            reason: wrapReason(reason)
           });
         });
       } else if (data.streamId) {
         _this._createStreamSink(data);
       } else {
-        action[0].call(action[1], data.data);
+        action(data.data);
       }
     } else {
-      throw new Error('Unknown action from worker: ' + data.action);
+      throw new Error("Unknown action from worker: ".concat(data.action));
     }
   };
+
   comObj.addEventListener('message', this._onComObjOnMessage);
 }
+
 MessageHandler.prototype = {
-  on: function on(actionName, handler, scope) {
+  on: function on(actionName, handler) {
     var ah = this.actionHandler;
+
     if (ah[actionName]) {
-      throw new Error('There is already an actionName called "' + actionName + '"');
+      throw new Error("There is already an actionName called \"".concat(actionName, "\""));
     }
-    ah[actionName] = [handler, scope];
+
+    ah[actionName] = handler;
   },
   send: function send(actionName, data, transfers) {
-    var message = {
+    this.postMessage({
       sourceName: this.sourceName,
       targetName: this.targetName,
       action: actionName,
       data: data
-    };
-    this.postMessage(message, transfers);
+    }, transfers);
   },
   sendWithPromise: function sendWithPromise(actionName, data, transfers) {
     var callbackId = this.callbackId++;
-    var message = {
-      sourceName: this.sourceName,
-      targetName: this.targetName,
-      action: actionName,
-      data: data,
-      callbackId: callbackId
-    };
     var capability = (0, _util.createPromiseCapability)();
     this.callbacksCapabilities[callbackId] = capability;
+
     try {
-      this.postMessage(message, transfers);
-    } catch (e) {
-      capability.reject(e);
+      this.postMessage({
+        sourceName: this.sourceName,
+        targetName: this.targetName,
+        action: actionName,
+        callbackId: callbackId,
+        data: data
+      }, transfers);
+    } catch (ex) {
+      capability.reject(ex);
     }
+
     return capability.promise;
   },
   sendWithStream: function sendWithStream(actionName, data, queueingStrategy, transfers) {
@@ -180,14 +184,18 @@ MessageHandler.prototype = {
     var streamId = this.streamId++;
     var sourceName = this.sourceName;
     var targetName = this.targetName;
+    var comObj = this.comObj;
     return new _util.ReadableStream({
       start: function start(controller) {
         var startCapability = (0, _util.createPromiseCapability)();
         _this2.streamControllers[streamId] = {
           controller: controller,
           startCall: startCapability,
+          pullCall: null,
+          cancelCall: null,
           isClosed: false
         };
+
         _this2.postMessage({
           sourceName: sourceName,
           targetName: targetName,
@@ -195,39 +203,39 @@ MessageHandler.prototype = {
           streamId: streamId,
           data: data,
           desiredSize: controller.desiredSize
-        });
+        }, transfers);
+
         return startCapability.promise;
       },
       pull: function pull(controller) {
         var pullCapability = (0, _util.createPromiseCapability)();
         _this2.streamControllers[streamId].pullCall = pullCapability;
-        _this2.postMessage({
+        comObj.postMessage({
           sourceName: sourceName,
           targetName: targetName,
-          stream: 'pull',
+          stream: StreamKind.PULL,
           streamId: streamId,
           desiredSize: controller.desiredSize
         });
         return pullCapability.promise;
       },
       cancel: function cancel(reason) {
+        (0, _util.assert)(reason instanceof Error, 'cancel must have a valid reason');
         var cancelCapability = (0, _util.createPromiseCapability)();
         _this2.streamControllers[streamId].cancelCall = cancelCapability;
         _this2.streamControllers[streamId].isClosed = true;
-        _this2.postMessage({
+        comObj.postMessage({
           sourceName: sourceName,
           targetName: targetName,
-          stream: 'cancel',
-          reason: reason,
-          streamId: streamId
+          stream: StreamKind.CANCEL,
+          streamId: streamId,
+          reason: wrapReason(reason)
         });
         return cancelCapability.promise;
       }
     }, queueingStrategy);
   },
   _createStreamSink: function _createStreamSink(data) {
-    var _this3 = this;
-
     var self = this;
     var action = this.actionHandler[data.action];
     var streamId = data.streamId;
@@ -235,62 +243,62 @@ MessageHandler.prototype = {
     var sourceName = this.sourceName;
     var targetName = data.sourceName;
     var capability = (0, _util.createPromiseCapability)();
-    var sendStreamRequest = function sendStreamRequest(_ref) {
-      var stream = _ref.stream,
-          chunk = _ref.chunk,
-          transfers = _ref.transfers,
-          success = _ref.success,
-          reason = _ref.reason;
-
-      _this3.postMessage({
-        sourceName: sourceName,
-        targetName: targetName,
-        stream: stream,
-        streamId: streamId,
-        chunk: chunk,
-        success: success,
-        reason: reason
-      }, transfers);
-    };
+    var comObj = this.comObj;
     var streamSink = {
       enqueue: function enqueue(chunk) {
         var size = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : 1;
-        var transfers = arguments[2];
+        var transfers = arguments.length > 2 ? arguments[2] : undefined;
 
         if (this.isCancelled) {
           return;
         }
+
         var lastDesiredSize = this.desiredSize;
         this.desiredSize -= size;
+
         if (lastDesiredSize > 0 && this.desiredSize <= 0) {
           this.sinkCapability = (0, _util.createPromiseCapability)();
           this.ready = this.sinkCapability.promise;
         }
-        sendStreamRequest({
-          stream: 'enqueue',
-          chunk: chunk,
-          transfers: transfers
-        });
+
+        self.postMessage({
+          sourceName: sourceName,
+          targetName: targetName,
+          stream: StreamKind.ENQUEUE,
+          streamId: streamId,
+          chunk: chunk
+        }, transfers);
       },
       close: function close() {
         if (this.isCancelled) {
           return;
         }
+
         this.isCancelled = true;
-        sendStreamRequest({ stream: 'close' });
+        comObj.postMessage({
+          sourceName: sourceName,
+          targetName: targetName,
+          stream: StreamKind.CLOSE,
+          streamId: streamId
+        });
         delete self.streamSinks[streamId];
       },
       error: function error(reason) {
+        (0, _util.assert)(reason instanceof Error, 'error must have a valid reason');
+
         if (this.isCancelled) {
           return;
         }
+
         this.isCancelled = true;
-        sendStreamRequest({
-          stream: 'error',
-          reason: reason
+        comObj.postMessage({
+          sourceName: sourceName,
+          targetName: targetName,
+          stream: StreamKind.ERROR,
+          streamId: streamId,
+          reason: wrapReason(reason)
         });
       },
-
       sinkCapability: capability,
       onPull: null,
       onCancel: null,
@@ -301,122 +309,168 @@ MessageHandler.prototype = {
     streamSink.sinkCapability.resolve();
     streamSink.ready = streamSink.sinkCapability.promise;
     this.streamSinks[streamId] = streamSink;
-    resolveCall(action[0], [data.data, streamSink], action[1]).then(function () {
-      sendStreamRequest({
-        stream: 'start_complete',
+    new Promise(function (resolve) {
+      resolve(action(data.data, streamSink));
+    }).then(function () {
+      comObj.postMessage({
+        sourceName: sourceName,
+        targetName: targetName,
+        stream: StreamKind.START_COMPLETE,
+        streamId: streamId,
         success: true
       });
     }, function (reason) {
-      sendStreamRequest({
-        stream: 'start_complete',
-        success: false,
-        reason: reason
+      comObj.postMessage({
+        sourceName: sourceName,
+        targetName: targetName,
+        stream: StreamKind.START_COMPLETE,
+        streamId: streamId,
+        reason: wrapReason(reason)
       });
     });
   },
   _processStreamMessage: function _processStreamMessage(data) {
-    var _this4 = this;
+    var _this3 = this;
 
     var sourceName = this.sourceName;
     var targetName = data.sourceName;
     var streamId = data.streamId;
-    var sendStreamResponse = function sendStreamResponse(_ref2) {
-      var stream = _ref2.stream,
-          success = _ref2.success,
-          reason = _ref2.reason;
+    var comObj = this.comObj;
 
-      _this4.comObj.postMessage({
-        sourceName: sourceName,
-        targetName: targetName,
-        stream: stream,
-        success: success,
-        streamId: streamId,
-        reason: reason
-      });
-    };
     var deleteStreamController = function deleteStreamController() {
-      Promise.all([_this4.streamControllers[data.streamId].startCall, _this4.streamControllers[data.streamId].pullCall, _this4.streamControllers[data.streamId].cancelCall].map(function (capability) {
-        return capability && finalize(capability.promise);
+      Promise.all([_this3.streamControllers[streamId].startCall, _this3.streamControllers[streamId].pullCall, _this3.streamControllers[streamId].cancelCall].map(function (capability) {
+        return capability && capability.promise["catch"](function () {});
       })).then(function () {
-        delete _this4.streamControllers[data.streamId];
+        delete _this3.streamControllers[streamId];
       });
     };
+
     switch (data.stream) {
-      case 'start_complete':
-        resolveOrReject(this.streamControllers[data.streamId].startCall, data.success, wrapReason(data.reason));
+      case StreamKind.START_COMPLETE:
+        if (data.success) {
+          this.streamControllers[streamId].startCall.resolve();
+        } else {
+          this.streamControllers[streamId].startCall.reject(wrapReason(data.reason));
+        }
+
         break;
-      case 'pull_complete':
-        resolveOrReject(this.streamControllers[data.streamId].pullCall, data.success, wrapReason(data.reason));
+
+      case StreamKind.PULL_COMPLETE:
+        if (data.success) {
+          this.streamControllers[streamId].pullCall.resolve();
+        } else {
+          this.streamControllers[streamId].pullCall.reject(wrapReason(data.reason));
+        }
+
         break;
-      case 'pull':
-        if (!this.streamSinks[data.streamId]) {
-          sendStreamResponse({
-            stream: 'pull_complete',
+
+      case StreamKind.PULL:
+        if (!this.streamSinks[streamId]) {
+          comObj.postMessage({
+            sourceName: sourceName,
+            targetName: targetName,
+            stream: StreamKind.PULL_COMPLETE,
+            streamId: streamId,
             success: true
           });
           break;
         }
-        if (this.streamSinks[data.streamId].desiredSize <= 0 && data.desiredSize > 0) {
-          this.streamSinks[data.streamId].sinkCapability.resolve();
+
+        if (this.streamSinks[streamId].desiredSize <= 0 && data.desiredSize > 0) {
+          this.streamSinks[streamId].sinkCapability.resolve();
         }
-        this.streamSinks[data.streamId].desiredSize = data.desiredSize;
-        resolveCall(this.streamSinks[data.streamId].onPull).then(function () {
-          sendStreamResponse({
-            stream: 'pull_complete',
+
+        this.streamSinks[streamId].desiredSize = data.desiredSize;
+        var onPull = this.streamSinks[data.streamId].onPull;
+        new Promise(function (resolve) {
+          resolve(onPull && onPull());
+        }).then(function () {
+          comObj.postMessage({
+            sourceName: sourceName,
+            targetName: targetName,
+            stream: StreamKind.PULL_COMPLETE,
+            streamId: streamId,
             success: true
           });
         }, function (reason) {
-          sendStreamResponse({
-            stream: 'pull_complete',
-            success: false,
-            reason: reason
+          comObj.postMessage({
+            sourceName: sourceName,
+            targetName: targetName,
+            stream: StreamKind.PULL_COMPLETE,
+            streamId: streamId,
+            reason: wrapReason(reason)
           });
         });
         break;
-      case 'enqueue':
-        (0, _util.assert)(this.streamControllers[data.streamId], 'enqueue should have stream controller');
-        if (!this.streamControllers[data.streamId].isClosed) {
-          this.streamControllers[data.streamId].controller.enqueue(data.chunk);
+
+      case StreamKind.ENQUEUE:
+        (0, _util.assert)(this.streamControllers[streamId], 'enqueue should have stream controller');
+
+        if (this.streamControllers[streamId].isClosed) {
+          break;
         }
+
+        this.streamControllers[streamId].controller.enqueue(data.chunk);
         break;
-      case 'close':
-        (0, _util.assert)(this.streamControllers[data.streamId], 'close should have stream controller');
-        if (this.streamControllers[data.streamId].isClosed) {
+
+      case StreamKind.CLOSE:
+        (0, _util.assert)(this.streamControllers[streamId], 'close should have stream controller');
+
+        if (this.streamControllers[streamId].isClosed) {
           break;
         }
-        this.streamControllers[data.streamId].isClosed = true;
-        this.streamControllers[data.streamId].controller.close();
+
+        this.streamControllers[streamId].isClosed = true;
+        this.streamControllers[streamId].controller.close();
         deleteStreamController();
         break;
-      case 'error':
-        (0, _util.assert)(this.streamControllers[data.streamId], 'error should have stream controller');
-        this.streamControllers[data.streamId].controller.error(wrapReason(data.reason));
+
+      case StreamKind.ERROR:
+        (0, _util.assert)(this.streamControllers[streamId], 'error should have stream controller');
+        this.streamControllers[streamId].controller.error(wrapReason(data.reason));
         deleteStreamController();
         break;
-      case 'cancel_complete':
-        resolveOrReject(this.streamControllers[data.streamId].cancelCall, data.success, wrapReason(data.reason));
+
+      case StreamKind.CANCEL_COMPLETE:
+        if (data.success) {
+          this.streamControllers[streamId].cancelCall.resolve();
+        } else {
+          this.streamControllers[streamId].cancelCall.reject(wrapReason(data.reason));
+        }
+
         deleteStreamController();
         break;
-      case 'cancel':
-        if (!this.streamSinks[data.streamId]) {
+
+      case StreamKind.CANCEL:
+        if (!this.streamSinks[streamId]) {
           break;
         }
-        resolveCall(this.streamSinks[data.streamId].onCancel, [wrapReason(data.reason)]).then(function () {
-          sendStreamResponse({
-            stream: 'cancel_complete',
+
+        var onCancel = this.streamSinks[data.streamId].onCancel;
+        new Promise(function (resolve) {
+          resolve(onCancel && onCancel(wrapReason(data.reason)));
+        }).then(function () {
+          comObj.postMessage({
+            sourceName: sourceName,
+            targetName: targetName,
+            stream: StreamKind.CANCEL_COMPLETE,
+            streamId: streamId,
             success: true
           });
         }, function (reason) {
-          sendStreamResponse({
-            stream: 'cancel_complete',
-            success: false,
-            reason: reason
+          comObj.postMessage({
+            sourceName: sourceName,
+            targetName: targetName,
+            stream: StreamKind.CANCEL_COMPLETE,
+            streamId: streamId,
+            reason: wrapReason(reason)
           });
         });
-        this.streamSinks[data.streamId].sinkCapability.reject(wrapReason(data.reason));
-        this.streamSinks[data.streamId].isCancelled = true;
-        delete this.streamSinks[data.streamId];
+        this.streamSinks[streamId].sinkCapability.reject(wrapReason(data.reason));
+        this.streamSinks[streamId].isCancelled = true;
+        delete this.streamSinks[streamId];
         break;
+
       default:
         throw new Error('Unexpected stream case');
     }
@@ -431,5 +485,4 @@ MessageHandler.prototype = {
   destroy: function destroy() {
     this.comObj.removeEventListener('message', this._onComObjOnMessage);
   }
-};
-exports.MessageHandler = MessageHandler;
+};