pdfjs-dist 2.3.200 → 2.4.456

package/lib/display/network.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,45 +26,27 @@ Object.defineProperty(exports, "__esModule", {
 });
 exports.PDFNetworkStream = void 0;
 
-var _regenerator = _interopRequireDefault(require("@babel/runtime/regenerator"));
+var _util = require("../shared/util.js");
 
-var _util = require("../shared/util");
-
-var _network_utils = require("./network_utils");
-
-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 _network_utils = require("./network_utils.js");
 
 ;
-var OK_RESPONSE = 200;
-var PARTIAL_CONTENT_RESPONSE = 206;
+const OK_RESPONSE = 200;
+const PARTIAL_CONTENT_RESPONSE = 206;
 
 function getArrayBuffer(xhr) {
-  var data = xhr.response;
+  const data = xhr.response;
 
-  if (typeof data !== 'string') {
+  if (typeof data !== "string") {
     return data;
   }
 
-  var array = (0, _util.stringToBytes)(data);
+  const array = (0, _util.stringToBytes)(data);
   return array.buffer;
 }
 
-var NetworkManager =
-/*#__PURE__*/
-function () {
-  function NetworkManager(url, args) {
-    _classCallCheck(this, NetworkManager);
-
+class NetworkManager {
+  constructor(url, args) {
     this.url = url;
     args = args || {};
     this.isHttp = /^https?:/i.test(url);
@@ -79,190 +61,173 @@ function () {
     this.pendingRequests = Object.create(null);
   }
 
-  _createClass(NetworkManager, [{
-    key: "requestRange",
-    value: function requestRange(begin, end, listeners) {
-      var args = {
-        begin: begin,
-        end: end
-      };
-
-      for (var prop in listeners) {
-        args[prop] = listeners[prop];
-      }
+  requestRange(begin, end, listeners) {
+    const args = {
+      begin,
+      end
+    };
 
-      return this.request(args);
+    for (const prop in listeners) {
+      args[prop] = listeners[prop];
     }
-  }, {
-    key: "requestFull",
-    value: function requestFull(listeners) {
-      return this.request(listeners);
-    }
-  }, {
-    key: "request",
-    value: function request(args) {
-      var xhr = this.getXhr();
-      var xhrId = this.currXhrId++;
-      var pendingRequest = this.pendingRequests[xhrId] = {
-        xhr: xhr
-      };
-      xhr.open('GET', this.url);
-      xhr.withCredentials = this.withCredentials;
-
-      for (var property in this.httpHeaders) {
-        var value = this.httpHeaders[property];
 
-        if (typeof value === 'undefined') {
-          continue;
-        }
+    return this.request(args);
+  }
 
-        xhr.setRequestHeader(property, value);
-      }
+  requestFull(listeners) {
+    return this.request(listeners);
+  }
 
-      if (this.isHttp && 'begin' in args && 'end' in args) {
-        xhr.setRequestHeader('Range', "bytes=".concat(args.begin, "-").concat(args.end - 1));
-        pendingRequest.expectedStatus = PARTIAL_CONTENT_RESPONSE;
-      } else {
-        pendingRequest.expectedStatus = OK_RESPONSE;
-      }
+  request(args) {
+    const xhr = this.getXhr();
+    const xhrId = this.currXhrId++;
+    const pendingRequest = this.pendingRequests[xhrId] = {
+      xhr
+    };
+    xhr.open("GET", this.url);
+    xhr.withCredentials = this.withCredentials;
 
-      xhr.responseType = 'arraybuffer';
+    for (const property in this.httpHeaders) {
+      const value = this.httpHeaders[property];
 
-      if (args.onError) {
-        xhr.onerror = function (evt) {
-          args.onError(xhr.status);
-        };
+      if (typeof value === "undefined") {
+        continue;
       }
 
-      xhr.onreadystatechange = this.onStateChange.bind(this, xhrId);
-      xhr.onprogress = this.onProgress.bind(this, xhrId);
-      pendingRequest.onHeadersReceived = args.onHeadersReceived;
-      pendingRequest.onDone = args.onDone;
-      pendingRequest.onError = args.onError;
-      pendingRequest.onProgress = args.onProgress;
-      xhr.send(null);
-      return xhrId;
-    }
-  }, {
-    key: "onProgress",
-    value: function onProgress(xhrId, evt) {
-      var pendingRequest = this.pendingRequests[xhrId];
-
-      if (!pendingRequest) {
-        return;
-      }
+      xhr.setRequestHeader(property, value);
+    }
 
-      if (pendingRequest.onProgress) {
-        pendingRequest.onProgress(evt);
-      }
+    if (this.isHttp && "begin" in args && "end" in args) {
+      xhr.setRequestHeader("Range", `bytes=${args.begin}-${args.end - 1}`);
+      pendingRequest.expectedStatus = PARTIAL_CONTENT_RESPONSE;
+    } else {
+      pendingRequest.expectedStatus = OK_RESPONSE;
     }
-  }, {
-    key: "onStateChange",
-    value: function onStateChange(xhrId, evt) {
-      var pendingRequest = this.pendingRequests[xhrId];
 
-      if (!pendingRequest) {
-        return;
-      }
+    xhr.responseType = "arraybuffer";
 
-      var xhr = pendingRequest.xhr;
+    if (args.onError) {
+      xhr.onerror = function (evt) {
+        args.onError(xhr.status);
+      };
+    }
 
-      if (xhr.readyState >= 2 && pendingRequest.onHeadersReceived) {
-        pendingRequest.onHeadersReceived();
-        delete pendingRequest.onHeadersReceived;
-      }
+    xhr.onreadystatechange = this.onStateChange.bind(this, xhrId);
+    xhr.onprogress = this.onProgress.bind(this, xhrId);
+    pendingRequest.onHeadersReceived = args.onHeadersReceived;
+    pendingRequest.onDone = args.onDone;
+    pendingRequest.onError = args.onError;
+    pendingRequest.onProgress = args.onProgress;
+    xhr.send(null);
+    return xhrId;
+  }
 
-      if (xhr.readyState !== 4) {
-        return;
-      }
+  onProgress(xhrId, evt) {
+    const pendingRequest = this.pendingRequests[xhrId];
 
-      if (!(xhrId in this.pendingRequests)) {
-        return;
-      }
+    if (!pendingRequest) {
+      return;
+    }
 
-      delete this.pendingRequests[xhrId];
+    if (pendingRequest.onProgress) {
+      pendingRequest.onProgress(evt);
+    }
+  }
 
-      if (xhr.status === 0 && this.isHttp) {
-        if (pendingRequest.onError) {
-          pendingRequest.onError(xhr.status);
-        }
+  onStateChange(xhrId, evt) {
+    const pendingRequest = this.pendingRequests[xhrId];
 
-        return;
-      }
+    if (!pendingRequest) {
+      return;
+    }
 
-      var xhrStatus = xhr.status || OK_RESPONSE;
-      var ok_response_on_range_request = xhrStatus === OK_RESPONSE && pendingRequest.expectedStatus === PARTIAL_CONTENT_RESPONSE;
+    const xhr = pendingRequest.xhr;
 
-      if (!ok_response_on_range_request && xhrStatus !== pendingRequest.expectedStatus) {
-        if (pendingRequest.onError) {
-          pendingRequest.onError(xhr.status);
-        }
+    if (xhr.readyState >= 2 && pendingRequest.onHeadersReceived) {
+      pendingRequest.onHeadersReceived();
+      delete pendingRequest.onHeadersReceived;
+    }
 
-        return;
-      }
+    if (xhr.readyState !== 4) {
+      return;
+    }
 
-      var chunk = getArrayBuffer(xhr);
+    if (!(xhrId in this.pendingRequests)) {
+      return;
+    }
 
-      if (xhrStatus === PARTIAL_CONTENT_RESPONSE) {
-        var rangeHeader = xhr.getResponseHeader('Content-Range');
-        var matches = /bytes (\d+)-(\d+)\/(\d+)/.exec(rangeHeader);
-        pendingRequest.onDone({
-          begin: parseInt(matches[1], 10),
-          chunk: chunk
-        });
-      } else if (chunk) {
-        pendingRequest.onDone({
-          begin: 0,
-          chunk: chunk
-        });
-      } else if (pendingRequest.onError) {
+    delete this.pendingRequests[xhrId];
+
+    if (xhr.status === 0 && this.isHttp) {
+      if (pendingRequest.onError) {
         pendingRequest.onError(xhr.status);
       }
+
+      return;
     }
-  }, {
-    key: "hasPendingRequests",
-    value: function hasPendingRequests() {
-      for (var xhrId in this.pendingRequests) {
-        return true;
+
+    const xhrStatus = xhr.status || OK_RESPONSE;
+    const ok_response_on_range_request = xhrStatus === OK_RESPONSE && pendingRequest.expectedStatus === PARTIAL_CONTENT_RESPONSE;
+
+    if (!ok_response_on_range_request && xhrStatus !== pendingRequest.expectedStatus) {
+      if (pendingRequest.onError) {
+        pendingRequest.onError(xhr.status);
       }
 
-      return false;
-    }
-  }, {
-    key: "getRequestXhr",
-    value: function getRequestXhr(xhrId) {
-      return this.pendingRequests[xhrId].xhr;
+      return;
     }
-  }, {
-    key: "isPendingRequest",
-    value: function isPendingRequest(xhrId) {
-      return xhrId in this.pendingRequests;
+
+    const chunk = getArrayBuffer(xhr);
+
+    if (xhrStatus === PARTIAL_CONTENT_RESPONSE) {
+      const rangeHeader = xhr.getResponseHeader("Content-Range");
+      const matches = /bytes (\d+)-(\d+)\/(\d+)/.exec(rangeHeader);
+      pendingRequest.onDone({
+        begin: parseInt(matches[1], 10),
+        chunk
+      });
+    } else if (chunk) {
+      pendingRequest.onDone({
+        begin: 0,
+        chunk
+      });
+    } else if (pendingRequest.onError) {
+      pendingRequest.onError(xhr.status);
     }
-  }, {
-    key: "abortAllRequests",
-    value: function abortAllRequests() {
-      for (var xhrId in this.pendingRequests) {
-        this.abortRequest(xhrId | 0);
-      }
+  }
+
+  hasPendingRequests() {
+    for (const xhrId in this.pendingRequests) {
+      return true;
     }
-  }, {
-    key: "abortRequest",
-    value: function abortRequest(xhrId) {
-      var xhr = this.pendingRequests[xhrId].xhr;
-      delete this.pendingRequests[xhrId];
-      xhr.abort();
+
+    return false;
+  }
+
+  getRequestXhr(xhrId) {
+    return this.pendingRequests[xhrId].xhr;
+  }
+
+  isPendingRequest(xhrId) {
+    return xhrId in this.pendingRequests;
+  }
+
+  abortAllRequests() {
+    for (const xhrId in this.pendingRequests) {
+      this.abortRequest(xhrId | 0);
     }
-  }]);
+  }
 
-  return NetworkManager;
-}();
+  abortRequest(xhrId) {
+    const xhr = this.pendingRequests[xhrId].xhr;
+    delete this.pendingRequests[xhrId];
+    xhr.abort();
+  }
 
-var PDFNetworkStream =
-/*#__PURE__*/
-function () {
-  function PDFNetworkStream(source) {
-    _classCallCheck(this, PDFNetworkStream);
+}
 
+class PDFNetworkStream {
+  constructor(source) {
     this._source = source;
     this._manager = new NetworkManager(source.url, {
       httpHeaders: source.httpHeaders,
@@ -273,60 +238,49 @@ function () {
     this._rangeRequestReaders = [];
   }
 
-  _createClass(PDFNetworkStream, [{
-    key: "_onRangeRequestReaderClosed",
-    value: function _onRangeRequestReaderClosed(reader) {
-      var i = this._rangeRequestReaders.indexOf(reader);
+  _onRangeRequestReaderClosed(reader) {
+    const i = this._rangeRequestReaders.indexOf(reader);
 
-      if (i >= 0) {
-        this._rangeRequestReaders.splice(i, 1);
-      }
+    if (i >= 0) {
+      this._rangeRequestReaders.splice(i, 1);
     }
-  }, {
-    key: "getFullReader",
-    value: function getFullReader() {
-      (0, _util.assert)(!this._fullRequestReader);
-      this._fullRequestReader = new PDFNetworkStreamFullRequestReader(this._manager, this._source);
-      return this._fullRequestReader;
-    }
-  }, {
-    key: "getRangeReader",
-    value: function getRangeReader(begin, end) {
-      var reader = new PDFNetworkStreamRangeRequestReader(this._manager, begin, end);
-      reader.onClosed = this._onRangeRequestReaderClosed.bind(this);
+  }
 
-      this._rangeRequestReaders.push(reader);
+  getFullReader() {
+    (0, _util.assert)(!this._fullRequestReader);
+    this._fullRequestReader = new PDFNetworkStreamFullRequestReader(this._manager, this._source);
+    return this._fullRequestReader;
+  }
 
-      return reader;
-    }
-  }, {
-    key: "cancelAllRequests",
-    value: function cancelAllRequests(reason) {
-      if (this._fullRequestReader) {
-        this._fullRequestReader.cancel(reason);
-      }
+  getRangeReader(begin, end) {
+    const reader = new PDFNetworkStreamRangeRequestReader(this._manager, begin, end);
+    reader.onClosed = this._onRangeRequestReaderClosed.bind(this);
 
-      var readers = this._rangeRequestReaders.slice(0);
+    this._rangeRequestReaders.push(reader);
 
-      readers.forEach(function (reader) {
-        reader.cancel(reason);
-      });
+    return reader;
+  }
+
+  cancelAllRequests(reason) {
+    if (this._fullRequestReader) {
+      this._fullRequestReader.cancel(reason);
     }
-  }]);
 
-  return PDFNetworkStream;
-}();
+    const readers = this._rangeRequestReaders.slice(0);
 
-exports.PDFNetworkStream = PDFNetworkStream;
+    readers.forEach(function (reader) {
+      reader.cancel(reason);
+    });
+  }
+
+}
 
-var PDFNetworkStreamFullRequestReader =
-/*#__PURE__*/
-function () {
-  function PDFNetworkStreamFullRequestReader(manager, source) {
-    _classCallCheck(this, PDFNetworkStreamFullRequestReader);
+exports.PDFNetworkStream = PDFNetworkStream;
 
+class PDFNetworkStreamFullRequestReader {
+  constructor(manager, source) {
     this._manager = manager;
-    var args = {
+    const args = {
       onHeadersReceived: this._onHeadersReceived.bind(this),
       onDone: this._onDone.bind(this),
       onError: this._onError.bind(this),
@@ -353,218 +307,168 @@ function () {
     this.onProgress = null;
   }
 
-  _createClass(PDFNetworkStreamFullRequestReader, [{
-    key: "_onHeadersReceived",
-    value: function _onHeadersReceived() {
-      var fullRequestXhrId = this._fullRequestId;
+  _onHeadersReceived() {
+    const fullRequestXhrId = this._fullRequestId;
 
-      var fullRequestXhr = this._manager.getRequestXhr(fullRequestXhrId);
+    const fullRequestXhr = this._manager.getRequestXhr(fullRequestXhrId);
 
-      var getResponseHeader = function getResponseHeader(name) {
-        return fullRequestXhr.getResponseHeader(name);
-      };
+    const getResponseHeader = name => {
+      return fullRequestXhr.getResponseHeader(name);
+    };
 
-      var _validateRangeRequest = (0, _network_utils.validateRangeRequestCapabilities)({
-        getResponseHeader: getResponseHeader,
-        isHttp: this._manager.isHttp,
-        rangeChunkSize: this._rangeChunkSize,
-        disableRange: this._disableRange
-      }),
-          allowRangeRequests = _validateRangeRequest.allowRangeRequests,
-          suggestedLength = _validateRangeRequest.suggestedLength;
-
-      if (allowRangeRequests) {
-        this._isRangeSupported = true;
-      }
+    const {
+      allowRangeRequests,
+      suggestedLength
+    } = (0, _network_utils.validateRangeRequestCapabilities)({
+      getResponseHeader,
+      isHttp: this._manager.isHttp,
+      rangeChunkSize: this._rangeChunkSize,
+      disableRange: this._disableRange
+    });
 
-      this._contentLength = suggestedLength || this._contentLength;
-      this._filename = (0, _network_utils.extractFilenameFromHeader)(getResponseHeader);
+    if (allowRangeRequests) {
+      this._isRangeSupported = true;
+    }
 
-      if (this._isRangeSupported) {
-        this._manager.abortRequest(fullRequestXhrId);
-      }
+    this._contentLength = suggestedLength || this._contentLength;
+    this._filename = (0, _network_utils.extractFilenameFromHeader)(getResponseHeader);
 
-      this._headersReceivedCapability.resolve();
-    }
-  }, {
-    key: "_onDone",
-    value: function _onDone(args) {
-      if (args) {
-        if (this._requests.length > 0) {
-          var requestCapability = this._requests.shift();
-
-          requestCapability.resolve({
-            value: args.chunk,
-            done: false
-          });
-        } else {
-          this._cachedChunks.push(args.chunk);
-        }
-      }
+    if (this._isRangeSupported) {
+      this._manager.abortRequest(fullRequestXhrId);
+    }
 
-      this._done = true;
+    this._headersReceivedCapability.resolve();
+  }
 
-      if (this._cachedChunks.length > 0) {
-        return;
-      }
+  _onDone(args) {
+    if (args) {
+      if (this._requests.length > 0) {
+        const requestCapability = this._requests.shift();
 
-      this._requests.forEach(function (requestCapability) {
         requestCapability.resolve({
-          value: undefined,
-          done: true
+          value: args.chunk,
+          done: false
         });
-      });
-
-      this._requests = [];
+      } else {
+        this._cachedChunks.push(args.chunk);
+      }
     }
-  }, {
-    key: "_onError",
-    value: function _onError(status) {
-      var url = this._url;
-      var exception = (0, _network_utils.createResponseStatusError)(status, url);
-      this._storedError = exception;
 
-      this._headersReceivedCapability.reject(exception);
+    this._done = true;
+
+    if (this._cachedChunks.length > 0) {
+      return;
+    }
 
-      this._requests.forEach(function (requestCapability) {
-        requestCapability.reject(exception);
+    this._requests.forEach(function (requestCapability) {
+      requestCapability.resolve({
+        value: undefined,
+        done: true
       });
+    });
 
-      this._requests = [];
-      this._cachedChunks = [];
-    }
-  }, {
-    key: "_onProgress",
-    value: function _onProgress(data) {
-      if (this.onProgress) {
-        this.onProgress({
-          loaded: data.loaded,
-          total: data.lengthComputable ? data.total : this._contentLength
-        });
-      }
-    }
-  }, {
-    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._storedError) {
-                  _context.next = 2;
-                  break;
-                }
-
-                throw this._storedError;
-
-              case 2:
-                if (!(this._cachedChunks.length > 0)) {
-                  _context.next = 5;
-                  break;
-                }
-
-                chunk = this._cachedChunks.shift();
-                return _context.abrupt("return", {
-                  value: chunk,
-                  done: false
-                });
-
-              case 5:
-                if (!this._done) {
-                  _context.next = 7;
-                  break;
-                }
-
-                return _context.abrupt("return", {
-                  value: undefined,
-                  done: true
-                });
-
-              case 7:
-                requestCapability = (0, _util.createPromiseCapability)();
-
-                this._requests.push(requestCapability);
-
-                return _context.abrupt("return", requestCapability.promise);
-
-              case 10:
-              case "end":
-                return _context.stop();
-            }
-          }
-        }, _callee, this);
-      }));
-
-      function read() {
-        return _read.apply(this, arguments);
-      }
+    this._requests = [];
+  }
 
-      return read;
-    }()
-  }, {
-    key: "cancel",
-    value: function cancel(reason) {
-      this._done = true;
+  _onError(status) {
+    const url = this._url;
+    const exception = (0, _network_utils.createResponseStatusError)(status, url);
+    this._storedError = exception;
 
-      this._headersReceivedCapability.reject(reason);
+    this._headersReceivedCapability.reject(exception);
 
-      this._requests.forEach(function (requestCapability) {
-        requestCapability.resolve({
-          value: undefined,
-          done: true
-        });
+    this._requests.forEach(function (requestCapability) {
+      requestCapability.reject(exception);
+    });
+
+    this._requests = [];
+    this._cachedChunks = [];
+  }
+
+  _onProgress(data) {
+    if (this.onProgress) {
+      this.onProgress({
+        loaded: data.loaded,
+        total: data.lengthComputable ? data.total : this._contentLength
       });
+    }
+  }
 
-      this._requests = [];
+  get filename() {
+    return this._filename;
+  }
 
-      if (this._manager.isPendingRequest(this._fullRequestId)) {
-        this._manager.abortRequest(this._fullRequestId);
-      }
+  get isRangeSupported() {
+    return this._isRangeSupported;
+  }
 
-      this._fullRequestReader = null;
-    }
-  }, {
-    key: "filename",
-    get: function get() {
-      return this._filename;
-    }
-  }, {
-    key: "isRangeSupported",
-    get: function get() {
-      return this._isRangeSupported;
+  get isStreamingSupported() {
+    return this._isStreamingSupported;
+  }
+
+  get contentLength() {
+    return this._contentLength;
+  }
+
+  get headersReady() {
+    return this._headersReceivedCapability.promise;
+  }
+
+  async read() {
+    if (this._storedError) {
+      throw this._storedError;
     }
-  }, {
-    key: "isStreamingSupported",
-    get: function get() {
-      return this._isStreamingSupported;
+
+    if (this._cachedChunks.length > 0) {
+      const chunk = this._cachedChunks.shift();
+
+      return {
+        value: chunk,
+        done: false
+      };
     }
-  }, {
-    key: "contentLength",
-    get: function get() {
-      return this._contentLength;
+
+    if (this._done) {
+      return {
+        value: undefined,
+        done: true
+      };
     }
-  }, {
-    key: "headersReady",
-    get: function get() {
-      return this._headersReceivedCapability.promise;
+
+    const requestCapability = (0, _util.createPromiseCapability)();
+
+    this._requests.push(requestCapability);
+
+    return requestCapability.promise;
+  }
+
+  cancel(reason) {
+    this._done = true;
+
+    this._headersReceivedCapability.reject(reason);
+
+    this._requests.forEach(function (requestCapability) {
+      requestCapability.resolve({
+        value: undefined,
+        done: true
+      });
+    });
+
+    this._requests = [];
+
+    if (this._manager.isPendingRequest(this._fullRequestId)) {
+      this._manager.abortRequest(this._fullRequestId);
     }
-  }]);
 
-  return PDFNetworkStreamFullRequestReader;
-}();
+    this._fullRequestReader = null;
+  }
 
-var PDFNetworkStreamRangeRequestReader =
-/*#__PURE__*/
-function () {
-  function PDFNetworkStreamRangeRequestReader(manager, begin, end) {
-    _classCallCheck(this, PDFNetworkStreamRangeRequestReader);
+}
 
+class PDFNetworkStreamRangeRequestReader {
+  constructor(manager, begin, end) {
     this._manager = manager;
-    var args = {
+    const args = {
       onDone: this._onDone.bind(this),
       onProgress: this._onProgress.bind(this)
     };
@@ -576,132 +480,93 @@ function () {
     this.onClosed = null;
   }
 
-  _createClass(PDFNetworkStreamRangeRequestReader, [{
-    key: "_close",
-    value: function _close() {
-      if (this.onClosed) {
-        this.onClosed(this);
-      }
+  _close() {
+    if (this.onClosed) {
+      this.onClosed(this);
     }
-  }, {
-    key: "_onDone",
-    value: function _onDone(data) {
-      var chunk = data.chunk;
+  }
 
-      if (this._requests.length > 0) {
-        var requestCapability = this._requests.shift();
+  _onDone(data) {
+    const chunk = data.chunk;
 
-        requestCapability.resolve({
-          value: chunk,
-          done: false
-        });
-      } else {
-        this._queuedChunk = chunk;
-      }
+    if (this._requests.length > 0) {
+      const requestCapability = this._requests.shift();
+
+      requestCapability.resolve({
+        value: chunk,
+        done: false
+      });
+    } else {
+      this._queuedChunk = chunk;
+    }
 
-      this._done = true;
+    this._done = true;
 
-      this._requests.forEach(function (requestCapability) {
-        requestCapability.resolve({
-          value: undefined,
-          done: true
-        });
+    this._requests.forEach(function (requestCapability) {
+      requestCapability.resolve({
+        value: undefined,
+        done: true
       });
+    });
+
+    this._requests = [];
 
-      this._requests = [];
+    this._close();
+  }
 
-      this._close();
+  _onProgress(evt) {
+    if (!this.isStreamingSupported && this.onProgress) {
+      this.onProgress({
+        loaded: evt.loaded
+      });
     }
-  }, {
-    key: "_onProgress",
-    value: function _onProgress(evt) {
-      if (!this.isStreamingSupported && this.onProgress) {
-        this.onProgress({
-          loaded: evt.loaded
-        });
-      }
+  }
+
+  get isStreamingSupported() {
+    return false;
+  }
+
+  async read() {
+    if (this._queuedChunk !== null) {
+      const chunk = this._queuedChunk;
+      this._queuedChunk = null;
+      return {
+        value: chunk,
+        done: false
+      };
     }
-  }, {
-    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 !== null)) {
-                  _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._done) {
+      return {
+        value: undefined,
+        done: true
+      };
+    }
 
-      this._requests.forEach(function (requestCapability) {
-        requestCapability.resolve({
-          value: undefined,
-          done: true
-        });
-      });
+    const requestCapability = (0, _util.createPromiseCapability)();
 
-      this._requests = [];
+    this._requests.push(requestCapability);
 
-      if (this._manager.isPendingRequest(this._requestId)) {
-        this._manager.abortRequest(this._requestId);
-      }
+    return requestCapability.promise;
+  }
 
-      this._close();
-    }
-  }, {
-    key: "isStreamingSupported",
-    get: function get() {
-      return false;
+  cancel(reason) {
+    this._done = true;
+
+    this._requests.forEach(function (requestCapability) {
+      requestCapability.resolve({
+        value: undefined,
+        done: true
+      });
+    });
+
+    this._requests = [];
+
+    if (this._manager.isPendingRequest(this._requestId)) {
+      this._manager.abortRequest(this._requestId);
     }
-  }]);
 
-  return PDFNetworkStreamRangeRequestReader;
-}();
+    this._close();
+  }
+
+}