pdfjs-dist 2.2.228 → 2.6.347

package/lib/display/transport_stream.js

@@ -2,7 +2,7 @@
  * @licstart The following is the entire license notice for the
  * Javascript code in this page
  *
- * Copyright 2019 Mozilla Foundation
+ * Copyright 2020 Mozilla Foundation
  *
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
@@ -26,37 +26,17 @@ Object.defineProperty(exports, "__esModule", {
 });
 exports.PDFDataTransportStream = void 0;
 
-var _regenerator = _interopRequireDefault(require("@babel/runtime/regenerator"));
+var _util = require("../shared/util.js");
 
-var _util = require("../shared/util");
-
-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"); } }
-
-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 PDFDataTransportStream =
-/*#__PURE__*/
-function () {
-  function PDFDataTransportStream(params, pdfDataRangeTransport) {
-    var _this = this;
-
-    _classCallCheck(this, PDFDataTransportStream);
-
-    (0, _util.assert)(pdfDataRangeTransport);
+class PDFDataTransportStream {
+  constructor(params, pdfDataRangeTransport) {
+    (0, _util.assert)(pdfDataRangeTransport, 'PDFDataTransportStream - missing required "pdfDataRangeTransport" argument.');
     this._queuedChunks = [];
     this._progressiveDone = params.progressiveDone || false;
-    var initialData = params.initialData;
+    const initialData = params.initialData;
 
     if (initialData && initialData.length > 0) {
-      var buffer = new Uint8Array(initialData).buffer;
+      const buffer = new Uint8Array(initialData).buffer;
 
       this._queuedChunks.push(buffer);
     }
@@ -68,183 +48,147 @@ function () {
     this._fullRequestReader = null;
     this._rangeReaders = [];
 
-    this._pdfDataRangeTransport.addRangeListener(function (begin, chunk) {
-      _this._onReceiveData({
-        begin: begin,
-        chunk: chunk
+    this._pdfDataRangeTransport.addRangeListener((begin, chunk) => {
+      this._onReceiveData({
+        begin,
+        chunk
       });
     });
 
-    this._pdfDataRangeTransport.addProgressListener(function (loaded, total) {
-      _this._onProgress({
-        loaded: loaded,
-        total: total
+    this._pdfDataRangeTransport.addProgressListener((loaded, total) => {
+      this._onProgress({
+        loaded,
+        total
       });
     });
 
-    this._pdfDataRangeTransport.addProgressiveReadListener(function (chunk) {
-      _this._onReceiveData({
-        chunk: chunk
+    this._pdfDataRangeTransport.addProgressiveReadListener(chunk => {
+      this._onReceiveData({
+        chunk
       });
     });
 
-    this._pdfDataRangeTransport.addProgressiveDoneListener(function () {
-      _this._onProgressiveDone();
+    this._pdfDataRangeTransport.addProgressiveDoneListener(() => {
+      this._onProgressiveDone();
     });
 
     this._pdfDataRangeTransport.transportReady();
   }
 
-  _createClass(PDFDataTransportStream, [{
-    key: "_onReceiveData",
-    value: function _onReceiveData(args) {
-      var buffer = new Uint8Array(args.chunk).buffer;
+  _onReceiveData(args) {
+    const buffer = new Uint8Array(args.chunk).buffer;
 
-      if (args.begin === undefined) {
-        if (this._fullRequestReader) {
-          this._fullRequestReader._enqueue(buffer);
-        } else {
-          this._queuedChunks.push(buffer);
-        }
+    if (args.begin === undefined) {
+      if (this._fullRequestReader) {
+        this._fullRequestReader._enqueue(buffer);
       } else {
-        var found = this._rangeReaders.some(function (rangeReader) {
-          if (rangeReader._begin !== args.begin) {
-            return false;
-          }
+        this._queuedChunks.push(buffer);
+      }
+    } else {
+      const found = this._rangeReaders.some(function (rangeReader) {
+        if (rangeReader._begin !== args.begin) {
+          return false;
+        }
 
-          rangeReader._enqueue(buffer);
+        rangeReader._enqueue(buffer);
 
-          return true;
-        });
+        return true;
+      });
 
-        (0, _util.assert)(found);
-      }
+      (0, _util.assert)(found, "_onReceiveData - no `PDFDataTransportStreamRangeReader` instance found.");
     }
-  }, {
-    key: "_onProgress",
-    value: function _onProgress(evt) {
-      if (evt.total === undefined) {
-        var firstReader = this._rangeReaders[0];
-
-        if (firstReader && firstReader.onProgress) {
-          firstReader.onProgress({
-            loaded: evt.loaded
-          });
-        }
-      } else {
-        var fullReader = this._fullRequestReader;
+  }
 
-        if (fullReader && fullReader.onProgress) {
-          fullReader.onProgress({
-            loaded: evt.loaded,
-            total: evt.total
-          });
-        }
-      }
-    }
-  }, {
-    key: "_onProgressiveDone",
-    value: function _onProgressiveDone() {
-      if (this._fullRequestReader) {
-        this._fullRequestReader.progressiveDone();
-      }
+  get _progressiveDataLength() {
+    return this._fullRequestReader ? this._fullRequestReader._loaded : 0;
+  }
 
-      this._progressiveDone = true;
-    }
-  }, {
-    key: "_removeRangeReader",
-    value: function _removeRangeReader(reader) {
-      var i = this._rangeReaders.indexOf(reader);
+  _onProgress(evt) {
+    if (evt.total === undefined) {
+      const firstReader = this._rangeReaders[0];
 
-      if (i >= 0) {
-        this._rangeReaders.splice(i, 1);
+      if (firstReader && firstReader.onProgress) {
+        firstReader.onProgress({
+          loaded: evt.loaded
+        });
+      }
+    } else {
+      const fullReader = this._fullRequestReader;
+
+      if (fullReader && fullReader.onProgress) {
+        fullReader.onProgress({
+          loaded: evt.loaded,
+          total: evt.total
+        });
       }
     }
-  }, {
-    key: "getFullReader",
-    value: function getFullReader() {
-      (0, _util.assert)(!this._fullRequestReader);
-      var queuedChunks = this._queuedChunks;
-      this._queuedChunks = null;
-      return new PDFDataTransportStreamReader(this, queuedChunks, this._progressiveDone);
+  }
+
+  _onProgressiveDone() {
+    if (this._fullRequestReader) {
+      this._fullRequestReader.progressiveDone();
     }
-  }, {
-    key: "getRangeReader",
-    value: function getRangeReader(begin, end) {
-      if (end <= this._progressiveDataLength) {
-        return null;
-      }
 
-      var reader = new PDFDataTransportStreamRangeReader(this, begin, end);
+    this._progressiveDone = true;
+  }
+
+  _removeRangeReader(reader) {
+    const i = this._rangeReaders.indexOf(reader);
 
-      this._pdfDataRangeTransport.requestDataRange(begin, end);
+    if (i >= 0) {
+      this._rangeReaders.splice(i, 1);
+    }
+  }
 
-      this._rangeReaders.push(reader);
+  getFullReader() {
+    (0, _util.assert)(!this._fullRequestReader, "PDFDataTransportStream.getFullReader can only be called once.");
+    const queuedChunks = this._queuedChunks;
+    this._queuedChunks = null;
+    return new PDFDataTransportStreamReader(this, queuedChunks, this._progressiveDone);
+  }
 
-      return reader;
+  getRangeReader(begin, end) {
+    if (end <= this._progressiveDataLength) {
+      return null;
     }
-  }, {
-    key: "cancelAllRequests",
-    value: function cancelAllRequests(reason) {
-      if (this._fullRequestReader) {
-        this._fullRequestReader.cancel(reason);
-      }
 
-      var readers = this._rangeReaders.slice(0);
+    const reader = new PDFDataTransportStreamRangeReader(this, begin, end);
 
-      readers.forEach(function (rangeReader) {
-        rangeReader.cancel(reason);
-      });
+    this._pdfDataRangeTransport.requestDataRange(begin, end);
 
-      this._pdfDataRangeTransport.abort();
-    }
-  }, {
-    key: "_progressiveDataLength",
-    get: function get() {
-      return this._fullRequestReader ? this._fullRequestReader._loaded : 0;
+    this._rangeReaders.push(reader);
+
+    return reader;
+  }
+
+  cancelAllRequests(reason) {
+    if (this._fullRequestReader) {
+      this._fullRequestReader.cancel(reason);
     }
-  }]);
 
-  return PDFDataTransportStream;
-}();
+    const readers = this._rangeReaders.slice(0);
 
-exports.PDFDataTransportStream = PDFDataTransportStream;
+    readers.forEach(function (rangeReader) {
+      rangeReader.cancel(reason);
+    });
 
-var PDFDataTransportStreamReader =
-/*#__PURE__*/
-function () {
-  function PDFDataTransportStreamReader(stream, queuedChunks) {
-    var progressiveDone = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : false;
+    this._pdfDataRangeTransport.abort();
+  }
+
+}
 
-    _classCallCheck(this, PDFDataTransportStreamReader);
+exports.PDFDataTransportStream = PDFDataTransportStream;
 
+class PDFDataTransportStreamReader {
+  constructor(stream, queuedChunks, progressiveDone = false) {
     this._stream = stream;
     this._done = progressiveDone || false;
     this._filename = null;
     this._queuedChunks = queuedChunks || [];
     this._loaded = 0;
-    var _iteratorNormalCompletion = true;
-    var _didIteratorError = false;
-    var _iteratorError = undefined;
-
-    try {
-      for (var _iterator = this._queuedChunks[Symbol.iterator](), _step; !(_iteratorNormalCompletion = (_step = _iterator.next()).done); _iteratorNormalCompletion = true) {
-        var chunk = _step.value;
-        this._loaded += chunk.byteLength;
-      }
-    } catch (err) {
-      _didIteratorError = true;
-      _iteratorError = err;
-    } finally {
-      try {
-        if (!_iteratorNormalCompletion && _iterator["return"] != null) {
-          _iterator["return"]();
-        }
-      } finally {
-        if (_didIteratorError) {
-          throw _iteratorError;
-        }
-      }
+
+    for (const chunk of this._queuedChunks) {
+      this._loaded += chunk.byteLength;
     }
 
     this._requests = [];
@@ -253,139 +197,94 @@ function () {
     this.onProgress = null;
   }
 
-  _createClass(PDFDataTransportStreamReader, [{
-    key: "_enqueue",
-    value: function _enqueue(chunk) {
-      if (this._done) {
-        return;
-      }
+  _enqueue(chunk) {
+    if (this._done) {
+      return;
+    }
 
-      if (this._requests.length > 0) {
-        var requestCapability = this._requests.shift();
+    if (this._requests.length > 0) {
+      const requestCapability = this._requests.shift();
 
-        requestCapability.resolve({
-          value: chunk,
-          done: false
-        });
-      } else {
-        this._queuedChunks.push(chunk);
-      }
-
-      this._loaded += chunk.byteLength;
+      requestCapability.resolve({
+        value: chunk,
+        done: false
+      });
+    } else {
+      this._queuedChunks.push(chunk);
     }
-  }, {
-    key: "read",
-    value: function () {
-      var _read = _asyncToGenerator(
-      /*#__PURE__*/
-      _regenerator["default"].mark(function _callee() {
-        var chunk, requestCapability;
-        return _regenerator["default"].wrap(function _callee$(_context) {
-          while (1) {
-            switch (_context.prev = _context.next) {
-              case 0:
-                if (!(this._queuedChunks.length > 0)) {
-                  _context.next = 3;
-                  break;
-                }
-
-                chunk = this._queuedChunks.shift();
-                return _context.abrupt("return", {
-                  value: chunk,
-                  done: false
-                });
-
-              case 3:
-                if (!this._done) {
-                  _context.next = 5;
-                  break;
-                }
-
-                return _context.abrupt("return", {
-                  value: undefined,
-                  done: true
-                });
-
-              case 5:
-                requestCapability = (0, _util.createPromiseCapability)();
-
-                this._requests.push(requestCapability);
-
-                return _context.abrupt("return", requestCapability.promise);
-
-              case 8:
-              case "end":
-                return _context.stop();
-            }
-          }
-        }, _callee, this);
-      }));
-
-      function read() {
-        return _read.apply(this, arguments);
-      }
 
-      return read;
-    }()
-  }, {
-    key: "cancel",
-    value: function cancel(reason) {
-      this._done = true;
+    this._loaded += chunk.byteLength;
+  }
 
-      this._requests.forEach(function (requestCapability) {
-        requestCapability.resolve({
-          value: undefined,
-          done: true
-        });
-      });
+  get headersReady() {
+    return this._headersReady;
+  }
 
-      this._requests = [];
-    }
-  }, {
-    key: "progressiveDone",
-    value: function progressiveDone() {
-      if (this._done) {
-        return;
-      }
+  get filename() {
+    return this._filename;
+  }
 
-      this._done = true;
-    }
-  }, {
-    key: "headersReady",
-    get: function get() {
-      return this._headersReady;
-    }
-  }, {
-    key: "filename",
-    get: function get() {
-      return this._filename;
-    }
-  }, {
-    key: "isRangeSupported",
-    get: function get() {
-      return this._stream._isRangeSupported;
+  get isRangeSupported() {
+    return this._stream._isRangeSupported;
+  }
+
+  get isStreamingSupported() {
+    return this._stream._isStreamingSupported;
+  }
+
+  get contentLength() {
+    return this._stream._contentLength;
+  }
+
+  async read() {
+    if (this._queuedChunks.length > 0) {
+      const chunk = this._queuedChunks.shift();
+
+      return {
+        value: chunk,
+        done: false
+      };
     }
-  }, {
-    key: "isStreamingSupported",
-    get: function get() {
-      return this._stream._isStreamingSupported;
+
+    if (this._done) {
+      return {
+        value: undefined,
+        done: true
+      };
     }
-  }, {
-    key: "contentLength",
-    get: function get() {
-      return this._stream._contentLength;
+
+    const requestCapability = (0, _util.createPromiseCapability)();
+
+    this._requests.push(requestCapability);
+
+    return requestCapability.promise;
+  }
+
+  cancel(reason) {
+    this._done = true;
+
+    this._requests.forEach(function (requestCapability) {
+      requestCapability.resolve({
+        value: undefined,
+        done: true
+      });
+    });
+
+    this._requests = [];
+  }
+
+  progressiveDone() {
+    if (this._done) {
+      return;
     }
-  }]);
 
-  return PDFDataTransportStreamReader;
-}();
+    this._done = true;
+  }
 
-var PDFDataTransportStreamRangeReader =
-/*#__PURE__*/
-function () {
-  function PDFDataTransportStreamRangeReader(stream, begin, end) {
-    _classCallCheck(this, PDFDataTransportStreamRangeReader);
+}
 
+class PDFDataTransportStreamRangeReader {
+  constructor(stream, begin, end) {
     this._stream = stream;
     this._begin = begin;
     this._end = end;
@@ -395,96 +294,20 @@ function () {
     this.onProgress = null;
   }
 
-  _createClass(PDFDataTransportStreamRangeReader, [{
-    key: "_enqueue",
-    value: function _enqueue(chunk) {
-      if (this._done) {
-        return;
-      }
-
-      if (this._requests.length === 0) {
-        this._queuedChunk = chunk;
-      } else {
-        var requestsCapability = this._requests.shift();
-
-        requestsCapability.resolve({
-          value: chunk,
-          done: false
-        });
-
-        this._requests.forEach(function (requestCapability) {
-          requestCapability.resolve({
-            value: undefined,
-            done: true
-          });
-        });
-
-        this._requests = [];
-      }
-
-      this._done = true;
-
-      this._stream._removeRangeReader(this);
+  _enqueue(chunk) {
+    if (this._done) {
+      return;
     }
-  }, {
-    key: "read",
-    value: function () {
-      var _read2 = _asyncToGenerator(
-      /*#__PURE__*/
-      _regenerator["default"].mark(function _callee2() {
-        var chunk, requestCapability;
-        return _regenerator["default"].wrap(function _callee2$(_context2) {
-          while (1) {
-            switch (_context2.prev = _context2.next) {
-              case 0:
-                if (!this._queuedChunk) {
-                  _context2.next = 4;
-                  break;
-                }
-
-                chunk = this._queuedChunk;
-                this._queuedChunk = null;
-                return _context2.abrupt("return", {
-                  value: chunk,
-                  done: false
-                });
-
-              case 4:
-                if (!this._done) {
-                  _context2.next = 6;
-                  break;
-                }
-
-                return _context2.abrupt("return", {
-                  value: undefined,
-                  done: true
-                });
-
-              case 6:
-                requestCapability = (0, _util.createPromiseCapability)();
-
-                this._requests.push(requestCapability);
-
-                return _context2.abrupt("return", requestCapability.promise);
-
-              case 9:
-              case "end":
-                return _context2.stop();
-            }
-          }
-        }, _callee2, this);
-      }));
-
-      function read() {
-        return _read2.apply(this, arguments);
-      }
 
-      return read;
-    }()
-  }, {
-    key: "cancel",
-    value: function cancel(reason) {
-      this._done = true;
+    if (this._requests.length === 0) {
+      this._queuedChunk = chunk;
+    } else {
+      const requestsCapability = this._requests.shift();
+
+      requestsCapability.resolve({
+        value: chunk,
+        done: false
+      });
 
       this._requests.forEach(function (requestCapability) {
         requestCapability.resolve({
@@ -494,15 +317,54 @@ function () {
       });
 
       this._requests = [];
+    }
 
-      this._stream._removeRangeReader(this);
+    this._done = true;
+
+    this._stream._removeRangeReader(this);
+  }
+
+  get isStreamingSupported() {
+    return false;
+  }
+
+  async read() {
+    if (this._queuedChunk) {
+      const chunk = this._queuedChunk;
+      this._queuedChunk = null;
+      return {
+        value: chunk,
+        done: false
+      };
     }
-  }, {
-    key: "isStreamingSupported",
-    get: function get() {
-      return false;
+
+    if (this._done) {
+      return {
+        value: undefined,
+        done: true
+      };
     }
-  }]);
 
-  return PDFDataTransportStreamRangeReader;
-}();
+    const requestCapability = (0, _util.createPromiseCapability)();
+
+    this._requests.push(requestCapability);
+
+    return requestCapability.promise;
+  }
+
+  cancel(reason) {
+    this._done = true;
+
+    this._requests.forEach(function (requestCapability) {
+      requestCapability.resolve({
+        value: undefined,
+        done: true
+      });
+    });
+
+    this._requests = [];
+
+    this._stream._removeRangeReader(this);
+  }
+
+}