Fix PDF viewer failing on Edge (not based on Chromium)

Since version v2.4.456 the PDF.js library is published as two different
packages, a non-translated/non-polyfilled build for modern browsers and
an ES5 compatible build for older browsers.

The PDF viewer was using the build for modern browsers, so it did not
work, for example, on Edge (the original version not based on Chromium).
This has been changed to use the ES5 build instead for maximum
compatibility.

Unfortunately, the ES5 build requires allowing "unsafe-eval" in the
iframe where the PDF.js library is loaded.

Signed-off-by: Daniel Calviño Sánchez <danxuliu@gmail.com>

1 files changed, 18113 insertions, 5914 deletions

diff --git a/js/pdfjs/build/pdf.js b/js/pdfjs/build/pdf.js
index a2ee957..24f3191 100644
--- a/js/pdfjs/build/pdf.js
+++ b/js/pdfjs/build/pdf.js
@@ -128,236 +128,235 @@ Object.defineProperty(exports, "__esModule", {
 });
 Object.defineProperty(exports, "addLinkAttributes", {
   enumerable: true,
-  get: function () {
+  get: function get() {
     return _display_utils.addLinkAttributes;
   }
 });
 Object.defineProperty(exports, "getFilenameFromUrl", {
   enumerable: true,
-  get: function () {
+  get: function get() {
     return _display_utils.getFilenameFromUrl;
   }
 });
 Object.defineProperty(exports, "LinkTarget", {
   enumerable: true,
-  get: function () {
+  get: function get() {
     return _display_utils.LinkTarget;
   }
 });
 Object.defineProperty(exports, "loadScript", {
   enumerable: true,
-  get: function () {
+  get: function get() {
     return _display_utils.loadScript;
   }
 });
 Object.defineProperty(exports, "PDFDateString", {
   enumerable: true,
-  get: function () {
+  get: function get() {
     return _display_utils.PDFDateString;
   }
 });
 Object.defineProperty(exports, "RenderingCancelledException", {
   enumerable: true,
-  get: function () {
+  get: function get() {
     return _display_utils.RenderingCancelledException;
   }
 });
 Object.defineProperty(exports, "build", {
   enumerable: true,
-  get: function () {
+  get: function get() {
     return _api.build;
   }
 });
 Object.defineProperty(exports, "getDocument", {
   enumerable: true,
-  get: function () {
+  get: function get() {
     return _api.getDocument;
   }
 });
 Object.defineProperty(exports, "LoopbackPort", {
   enumerable: true,
-  get: function () {
+  get: function get() {
     return _api.LoopbackPort;
   }
 });
 Object.defineProperty(exports, "PDFDataRangeTransport", {
   enumerable: true,
-  get: function () {
+  get: function get() {
     return _api.PDFDataRangeTransport;
   }
 });
 Object.defineProperty(exports, "PDFWorker", {
   enumerable: true,
-  get: function () {
+  get: function get() {
     return _api.PDFWorker;
   }
 });
 Object.defineProperty(exports, "version", {
   enumerable: true,
-  get: function () {
+  get: function get() {
     return _api.version;
   }
 });
 Object.defineProperty(exports, "CMapCompressionType", {
   enumerable: true,
-  get: function () {
+  get: function get() {
     return _util.CMapCompressionType;
   }
 });
 Object.defineProperty(exports, "createObjectURL", {
   enumerable: true,
-  get: function () {
+  get: function get() {
     return _util.createObjectURL;
   }
 });
 Object.defineProperty(exports, "createPromiseCapability", {
   enumerable: true,
-  get: function () {
+  get: function get() {
     return _util.createPromiseCapability;
   }
 });
 Object.defineProperty(exports, "createValidAbsoluteUrl", {
   enumerable: true,
-  get: function () {
+  get: function get() {
     return _util.createValidAbsoluteUrl;
   }
 });
 Object.defineProperty(exports, "InvalidPDFException", {
   enumerable: true,
-  get: function () {
+  get: function get() {
     return _util.InvalidPDFException;
   }
 });
 Object.defineProperty(exports, "MissingPDFException", {
   enumerable: true,
-  get: function () {
+  get: function get() {
     return _util.MissingPDFException;
   }
 });
 Object.defineProperty(exports, "OPS", {
   enumerable: true,
-  get: function () {
+  get: function get() {
     return _util.OPS;
   }
 });
 Object.defineProperty(exports, "PasswordResponses", {
   enumerable: true,
-  get: function () {
+  get: function get() {
     return _util.PasswordResponses;
   }
 });
 Object.defineProperty(exports, "PermissionFlag", {
   enumerable: true,
-  get: function () {
+  get: function get() {
     return _util.PermissionFlag;
   }
 });
 Object.defineProperty(exports, "removeNullCharacters", {
   enumerable: true,
-  get: function () {
+  get: function get() {
     return _util.removeNullCharacters;
   }
 });
 Object.defineProperty(exports, "shadow", {
   enumerable: true,
-  get: function () {
+  get: function get() {
     return _util.shadow;
   }
 });
 Object.defineProperty(exports, "UnexpectedResponseException", {
   enumerable: true,
-  get: function () {
+  get: function get() {
     return _util.UnexpectedResponseException;
   }
 });
 Object.defineProperty(exports, "UNSUPPORTED_FEATURES", {
   enumerable: true,
-  get: function () {
+  get: function get() {
     return _util.UNSUPPORTED_FEATURES;
   }
 });
 Object.defineProperty(exports, "Util", {
   enumerable: true,
-  get: function () {
+  get: function get() {
     return _util.Util;
   }
 });
 Object.defineProperty(exports, "VerbosityLevel", {
   enumerable: true,
-  get: function () {
+  get: function get() {
     return _util.VerbosityLevel;
   }
 });
 Object.defineProperty(exports, "AnnotationLayer", {
   enumerable: true,
-  get: function () {
+  get: function get() {
     return _annotation_layer.AnnotationLayer;
   }
 });
 Object.defineProperty(exports, "apiCompatibilityParams", {
   enumerable: true,
-  get: function () {
+  get: function get() {
     return _api_compatibility.apiCompatibilityParams;
   }
 });
 Object.defineProperty(exports, "GlobalWorkerOptions", {
   enumerable: true,
-  get: function () {
+  get: function get() {
     return _worker_options.GlobalWorkerOptions;
   }
 });
 Object.defineProperty(exports, "renderTextLayer", {
   enumerable: true,
-  get: function () {
+  get: function get() {
     return _text_layer.renderTextLayer;
   }
 });
 Object.defineProperty(exports, "SVGGraphics", {
   enumerable: true,
-  get: function () {
+  get: function get() {
     return _svg.SVGGraphics;
   }
 });
 
 var _display_utils = __w_pdfjs_require__(1);
 
-var _api = __w_pdfjs_require__(5);
+var _api = __w_pdfjs_require__(198);
 
-var _util = __w_pdfjs_require__(2);
+var _util = __w_pdfjs_require__(5);
 
-var _annotation_layer = __w_pdfjs_require__(16);
+var _annotation_layer = __w_pdfjs_require__(209);
 
-var _api_compatibility = __w_pdfjs_require__(7);
+var _api_compatibility = __w_pdfjs_require__(200);
 
-var _worker_options = __w_pdfjs_require__(10);
+var _worker_options = __w_pdfjs_require__(203);
 
-var _text_layer = __w_pdfjs_require__(17);
+var _text_layer = __w_pdfjs_require__(210);
 
-var _svg = __w_pdfjs_require__(18);
+var _svg = __w_pdfjs_require__(211);
 
-const pdfjsVersion = '2.5.207';
-const pdfjsBuild = '0974d6052';
+var pdfjsVersion = '2.5.207';
+var pdfjsBuild = '0974d6052';
 {
-  const {
-    isNodeJS
-  } = __w_pdfjs_require__(4);
+  var _require = __w_pdfjs_require__(7),
+      isNodeJS = _require.isNodeJS;
 
   if (isNodeJS) {
-    const PDFNodeStream = __w_pdfjs_require__(19).PDFNodeStream;
+    var PDFNodeStream = __w_pdfjs_require__(212).PDFNodeStream;
 
-    (0, _api.setPDFNetworkStreamFactory)(params => {
+    (0, _api.setPDFNetworkStreamFactory)(function (params) {
       return new PDFNodeStream(params);
     });
   } else {
-    const PDFNetworkStream = __w_pdfjs_require__(22).PDFNetworkStream;
+    var PDFNetworkStream = __w_pdfjs_require__(215).PDFNetworkStream;
 
-    let PDFFetchStream;
+    var PDFFetchStream;
 
     if ((0, _display_utils.isFetchSupported)()) {
-      PDFFetchStream = __w_pdfjs_require__(23).PDFFetchStream;
+      PDFFetchStream = __w_pdfjs_require__(216).PDFFetchStream;
     }
 
-    (0, _api.setPDFNetworkStreamFactory)(params => {
+    (0, _api.setPDFNetworkStreamFactory)(function (params) {
       if (PDFFetchStream && (0, _display_utils.isValidFetchUrl)(params.url)) {
         return new PDFFetchStream(params);
       }
@@ -385,184 +384,333 @@ exports.loadScript = loadScript;
 exports.deprecated = deprecated;
 exports.PDFDateString = exports.StatTimer = exports.DOMSVGFactory = exports.DOMCMapReaderFactory = exports.DOMCanvasFactory = exports.DEFAULT_LINK_REL = exports.LinkTarget = exports.RenderingCancelledException = exports.PageViewport = void 0;
 
-var _util = __w_pdfjs_require__(2);
+var _regenerator = _interopRequireDefault(__w_pdfjs_require__(2));
 
-const DEFAULT_LINK_REL = "noopener noreferrer nofollow";
-exports.DEFAULT_LINK_REL = DEFAULT_LINK_REL;
-const SVG_NS = "http://www.w3.org/2000/svg";
+var _util = __w_pdfjs_require__(5);
 
-class DOMCanvasFactory {
-  create(width, height) {
-    if (width <= 0 || height <= 0) {
-      throw new Error("Invalid canvas size");
-    }
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { "default": obj }; }
 
-    const canvas = document.createElement("canvas");
-    const context = canvas.getContext("2d");
-    canvas.width = width;
-    canvas.height = height;
-    return {
-      canvas,
-      context
-    };
-  }
+function _createForOfIteratorHelper(o, allowArrayLike) { var it; if (typeof Symbol === "undefined" || o[Symbol.iterator] == null) { if (Array.isArray(o) || (it = _unsupportedIterableToArray(o)) || allowArrayLike && o && typeof o.length === "number") { if (it) o = it; var i = 0; var F = function F() {}; return { s: F, n: function n() { if (i >= o.length) return { done: true }; return { done: false, value: o[i++] }; }, e: function e(_e) { throw _e; }, f: F }; } throw new TypeError("Invalid attempt to iterate non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method."); } var normalCompletion = true, didErr = false, err; return { s: function s() { it = o[Symbol.iterator](); }, n: function n() { var step = it.next(); normalCompletion = step.done; return step; }, e: function e(_e2) { didErr = true; err = _e2; }, f: function f() { try { if (!normalCompletion && it["return"] != null) it["return"](); } finally { if (didErr) throw err; } } }; }
 
-  reset(canvasAndContext, width, height) {
-    if (!canvasAndContext.canvas) {
-      throw new Error("Canvas is not specified");
-    }
+function _unsupportedIterableToArray(o, minLen) { if (!o) return; if (typeof o === "string") return _arrayLikeToArray(o, minLen); var n = Object.prototype.toString.call(o).slice(8, -1); if (n === "Object" && o.constructor) n = o.constructor.name; if (n === "Map" || n === "Set") return Array.from(o); if (n === "Arguments" || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(n)) return _arrayLikeToArray(o, minLen); }
 
-    if (width <= 0 || height <= 0) {
-      throw new Error("Invalid canvas size");
-    }
+function _arrayLikeToArray(arr, len) { if (len == null || len > arr.length) len = arr.length; for (var i = 0, arr2 = new Array(len); i < len; i++) { arr2[i] = arr[i]; } return arr2; }
 
-    canvasAndContext.canvas.width = width;
-    canvasAndContext.canvas.height = height;
-  }
+function _typeof(obj) { "@babel/helpers - typeof"; 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); }
 
-  destroy(canvasAndContext) {
-    if (!canvasAndContext.canvas) {
-      throw new Error("Canvas is not specified");
-    }
+function _inherits(subClass, superClass) { if (typeof superClass !== "function" && superClass !== null) { throw new TypeError("Super expression must either be null or a function"); } subClass.prototype = Object.create(superClass && superClass.prototype, { constructor: { value: subClass, writable: true, configurable: true } }); if (superClass) _setPrototypeOf(subClass, superClass); }
 
-    canvasAndContext.canvas.width = 0;
-    canvasAndContext.canvas.height = 0;
-    canvasAndContext.canvas = null;
-    canvasAndContext.context = null;
-  }
+function _setPrototypeOf(o, p) { _setPrototypeOf = Object.setPrototypeOf || function _setPrototypeOf(o, p) { o.__proto__ = p; return o; }; return _setPrototypeOf(o, p); }
 
-}
+function _createSuper(Derived) { var hasNativeReflectConstruct = _isNativeReflectConstruct(); return function _createSuperInternal() { var Super = _getPrototypeOf(Derived), result; if (hasNativeReflectConstruct) { var NewTarget = _getPrototypeOf(this).constructor; result = Reflect.construct(Super, arguments, NewTarget); } else { result = Super.apply(this, arguments); } return _possibleConstructorReturn(this, result); }; }
 
-exports.DOMCanvasFactory = DOMCanvasFactory;
+function _possibleConstructorReturn(self, call) { if (call && (_typeof(call) === "object" || typeof call === "function")) { return call; } return _assertThisInitialized(self); }
 
-class DOMCMapReaderFactory {
-  constructor({
-    baseUrl = null,
-    isCompressed = false
-  }) {
-    this.baseUrl = baseUrl;
-    this.isCompressed = isCompressed;
+function _assertThisInitialized(self) { if (self === void 0) { throw new ReferenceError("this hasn't been initialised - super() hasn't been called"); } return self; }
+
+function _isNativeReflectConstruct() { if (typeof Reflect === "undefined" || !Reflect.construct) return false; if (Reflect.construct.sham) return false; if (typeof Proxy === "function") return true; try { Date.prototype.toString.call(Reflect.construct(Date, [], function () {})); return true; } catch (e) { return false; } }
+
+function _getPrototypeOf(o) { _getPrototypeOf = Object.setPrototypeOf ? Object.getPrototypeOf : function _getPrototypeOf(o) { return o.__proto__ || Object.getPrototypeOf(o); }; return _getPrototypeOf(o); }
+
+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 DEFAULT_LINK_REL = "noopener noreferrer nofollow";
+exports.DEFAULT_LINK_REL = DEFAULT_LINK_REL;
+var SVG_NS = "http://www.w3.org/2000/svg";
+
+var DOMCanvasFactory = /*#__PURE__*/function () {
+  function DOMCanvasFactory() {
+    _classCallCheck(this, DOMCanvasFactory);
   }
 
-  async fetch({
-    name
-  }) {
-    if (!this.baseUrl) {
-      throw new Error('The CMap "baseUrl" parameter must be specified, ensure that ' + 'the "cMapUrl" and "cMapPacked" API parameters are provided.');
+  _createClass(DOMCanvasFactory, [{
+    key: "create",
+    value: function create(width, height) {
+      if (width <= 0 || height <= 0) {
+        throw new Error("Invalid canvas size");
+      }
+
+      var canvas = document.createElement("canvas");
+      var context = canvas.getContext("2d");
+      canvas.width = width;
+      canvas.height = height;
+      return {
+        canvas: canvas,
+        context: context
+      };
     }
+  }, {
+    key: "reset",
+    value: function reset(canvasAndContext, width, height) {
+      if (!canvasAndContext.canvas) {
+        throw new Error("Canvas is not specified");
+      }
 
-    if (!name) {
-      throw new Error("CMap name must be specified.");
+      if (width <= 0 || height <= 0) {
+        throw new Error("Invalid canvas size");
+      }
+
+      canvasAndContext.canvas.width = width;
+      canvasAndContext.canvas.height = height;
     }
+  }, {
+    key: "destroy",
+    value: function destroy(canvasAndContext) {
+      if (!canvasAndContext.canvas) {
+        throw new Error("Canvas is not specified");
+      }
 
-    const url = this.baseUrl + name + (this.isCompressed ? ".bcmap" : "");
-    const compressionType = this.isCompressed ? _util.CMapCompressionType.BINARY : _util.CMapCompressionType.NONE;
+      canvasAndContext.canvas.width = 0;
+      canvasAndContext.canvas.height = 0;
+      canvasAndContext.canvas = null;
+      canvasAndContext.context = null;
+    }
+  }]);
 
-    if (isFetchSupported() && isValidFetchUrl(url, document.baseURI)) {
-      return fetch(url).then(async response => {
-        if (!response.ok) {
-          throw new Error(response.statusText);
-        }
+  return DOMCanvasFactory;
+}();
 
-        let cMapData;
+exports.DOMCanvasFactory = DOMCanvasFactory;
 
-        if (this.isCompressed) {
-          cMapData = new Uint8Array(await response.arrayBuffer());
-        } else {
-          cMapData = (0, _util.stringToBytes)(await response.text());
-        }
+var DOMCMapReaderFactory = /*#__PURE__*/function () {
+  function DOMCMapReaderFactory(_ref) {
+    var _ref$baseUrl = _ref.baseUrl,
+        baseUrl = _ref$baseUrl === void 0 ? null : _ref$baseUrl,
+        _ref$isCompressed = _ref.isCompressed,
+        isCompressed = _ref$isCompressed === void 0 ? false : _ref$isCompressed;
 
-        return {
-          cMapData,
-          compressionType
-        };
-      }).catch(reason => {
-        throw new Error(`Unable to load ${this.isCompressed ? "binary " : ""}` + `CMap at: ${url}`);
-      });
-    }
+    _classCallCheck(this, DOMCMapReaderFactory);
 
-    return new Promise((resolve, reject) => {
-      const request = new XMLHttpRequest();
-      request.open("GET", url, true);
+    this.baseUrl = baseUrl;
+    this.isCompressed = isCompressed;
+  }
 
-      if (this.isCompressed) {
-        request.responseType = "arraybuffer";
+  _createClass(DOMCMapReaderFactory, [{
+    key: "fetch",
+    value: function (_fetch) {
+      function fetch(_x) {
+        return _fetch.apply(this, arguments);
       }
 
-      request.onreadystatechange = () => {
-        if (request.readyState !== XMLHttpRequest.DONE) {
-          return;
-        }
+      fetch.toString = function () {
+        return _fetch.toString();
+      };
 
-        if (request.status === 200 || request.status === 0) {
-          let cMapData;
+      return fetch;
+    }( /*#__PURE__*/function () {
+      var _ref3 = _asyncToGenerator( /*#__PURE__*/_regenerator["default"].mark(function _callee2(_ref2) {
+        var _this = this;
+
+        var name, url, compressionType;
+        return _regenerator["default"].wrap(function _callee2$(_context2) {
+          while (1) {
+            switch (_context2.prev = _context2.next) {
+              case 0:
+                name = _ref2.name;
+
+                if (this.baseUrl) {
+                  _context2.next = 3;
+                  break;
+                }
 
-          if (this.isCompressed && request.response) {
-            cMapData = new Uint8Array(request.response);
-          } else if (!this.isCompressed && request.responseText) {
-            cMapData = (0, _util.stringToBytes)(request.responseText);
-          }
+                throw new Error('The CMap "baseUrl" parameter must be specified, ensure that ' + 'the "cMapUrl" and "cMapPacked" API parameters are provided.');
 
-          if (cMapData) {
-            resolve({
-              cMapData,
-              compressionType
-            });
-            return;
+              case 3:
+                if (name) {
+                  _context2.next = 5;
+                  break;
+                }
+
+                throw new Error("CMap name must be specified.");
+
+              case 5:
+                url = this.baseUrl + name + (this.isCompressed ? ".bcmap" : "");
+                compressionType = this.isCompressed ? _util.CMapCompressionType.BINARY : _util.CMapCompressionType.NONE;
+
+                if (!(isFetchSupported() && isValidFetchUrl(url, document.baseURI))) {
+                  _context2.next = 9;
+                  break;
+                }
+
+                return _context2.abrupt("return", fetch(url).then( /*#__PURE__*/function () {
+                  var _ref4 = _asyncToGenerator( /*#__PURE__*/_regenerator["default"].mark(function _callee(response) {
+                    var cMapData;
+                    return _regenerator["default"].wrap(function _callee$(_context) {
+                      while (1) {
+                        switch (_context.prev = _context.next) {
+                          case 0:
+                            if (response.ok) {
+                              _context.next = 2;
+                              break;
+                            }
+
+                            throw new Error(response.statusText);
+
+                          case 2:
+                            if (!_this.isCompressed) {
+                              _context.next = 10;
+                              break;
+                            }
+
+                            _context.t0 = Uint8Array;
+                            _context.next = 6;
+                            return response.arrayBuffer();
+
+                          case 6:
+                            _context.t1 = _context.sent;
+                            cMapData = new _context.t0(_context.t1);
+                            _context.next = 15;
+                            break;
+
+                          case 10:
+                            _context.t2 = _util.stringToBytes;
+                            _context.next = 13;
+                            return response.text();
+
+                          case 13:
+                            _context.t3 = _context.sent;
+                            cMapData = (0, _context.t2)(_context.t3);
+
+                          case 15:
+                            return _context.abrupt("return", {
+                              cMapData: cMapData,
+                              compressionType: compressionType
+                            });
+
+                          case 16:
+                          case "end":
+                            return _context.stop();
+                        }
+                      }
+                    }, _callee);
+                  }));
+
+                  return function (_x3) {
+                    return _ref4.apply(this, arguments);
+                  };
+                }())["catch"](function (reason) {
+                  throw new Error("Unable to load ".concat(_this.isCompressed ? "binary " : "") + "CMap at: ".concat(url));
+                }));
+
+              case 9:
+                return _context2.abrupt("return", new Promise(function (resolve, reject) {
+                  var request = new XMLHttpRequest();
+                  request.open("GET", url, true);
+
+                  if (_this.isCompressed) {
+                    request.responseType = "arraybuffer";
+                  }
+
+                  request.onreadystatechange = function () {
+                    if (request.readyState !== XMLHttpRequest.DONE) {
+                      return;
+                    }
+
+                    if (request.status === 200 || request.status === 0) {
+                      var cMapData;
+
+                      if (_this.isCompressed && request.response) {
+                        cMapData = new Uint8Array(request.response);
+                      } else if (!_this.isCompressed && request.responseText) {
+                        cMapData = (0, _util.stringToBytes)(request.responseText);
+                      }
+
+                      if (cMapData) {
+                        resolve({
+                          cMapData: cMapData,
+                          compressionType: compressionType
+                        });
+                        return;
+                      }
+                    }
+
+                    reject(new Error(request.statusText));
+                  };
+
+                  request.send(null);
+                })["catch"](function (reason) {
+                  throw new Error("Unable to load ".concat(_this.isCompressed ? "binary " : "") + "CMap at: ".concat(url));
+                }));
+
+              case 10:
+              case "end":
+                return _context2.stop();
+            }
           }
-        }
+        }, _callee2, this);
+      }));
 
-        reject(new Error(request.statusText));
+      return function (_x2) {
+        return _ref3.apply(this, arguments);
       };
+    }())
+  }]);
 
-      request.send(null);
-    }).catch(reason => {
-      throw new Error(`Unable to load ${this.isCompressed ? "binary " : ""}` + `CMap at: ${url}`);
-    });
-  }
-
-}
+  return DOMCMapReaderFactory;
+}();
 
 exports.DOMCMapReaderFactory = DOMCMapReaderFactory;
 
-class DOMSVGFactory {
-  create(width, height) {
-    (0, _util.assert)(width > 0 && height > 0, "Invalid SVG dimensions");
-    const svg = document.createElementNS(SVG_NS, "svg:svg");
-    svg.setAttribute("version", "1.1");
-    svg.setAttribute("width", width + "px");
-    svg.setAttribute("height", height + "px");
-    svg.setAttribute("preserveAspectRatio", "none");
-    svg.setAttribute("viewBox", "0 0 " + width + " " + height);
-    return svg;
-  }
-
-  createElement(type) {
-    (0, _util.assert)(typeof type === "string", "Invalid SVG element type");
-    return document.createElementNS(SVG_NS, type);
-  }
+var DOMSVGFactory = /*#__PURE__*/function () {
+  function DOMSVGFactory() {
+    _classCallCheck(this, DOMSVGFactory);
+  }
+
+  _createClass(DOMSVGFactory, [{
+    key: "create",
+    value: function create(width, height) {
+      (0, _util.assert)(width > 0 && height > 0, "Invalid SVG dimensions");
+      var svg = document.createElementNS(SVG_NS, "svg:svg");
+      svg.setAttribute("version", "1.1");
+      svg.setAttribute("width", width + "px");
+      svg.setAttribute("height", height + "px");
+      svg.setAttribute("preserveAspectRatio", "none");
+      svg.setAttribute("viewBox", "0 0 " + width + " " + height);
+      return svg;
+    }
+  }, {
+    key: "createElement",
+    value: function createElement(type) {
+      (0, _util.assert)(typeof type === "string", "Invalid SVG element type");
+      return document.createElementNS(SVG_NS, type);
+    }
+  }]);
 
-}
+  return DOMSVGFactory;
+}();
 
 exports.DOMSVGFactory = DOMSVGFactory;
 
-class PageViewport {
-  constructor({
-    viewBox,
-    scale,
-    rotation,
-    offsetX = 0,
-    offsetY = 0,
-    dontFlip = false
-  }) {
+var PageViewport = /*#__PURE__*/function () {
+  function PageViewport(_ref5) {
+    var viewBox = _ref5.viewBox,
+        scale = _ref5.scale,
+        rotation = _ref5.rotation,
+        _ref5$offsetX = _ref5.offsetX,
+        offsetX = _ref5$offsetX === void 0 ? 0 : _ref5$offsetX,
+        _ref5$offsetY = _ref5.offsetY,
+        offsetY = _ref5$offsetY === void 0 ? 0 : _ref5$offsetY,
+        _ref5$dontFlip = _ref5.dontFlip,
+        dontFlip = _ref5$dontFlip === void 0 ? false : _ref5$dontFlip;
+
+    _classCallCheck(this, PageViewport);
+
     this.viewBox = viewBox;
     this.scale = scale;
     this.rotation = rotation;
     this.offsetX = offsetX;
     this.offsetY = offsetY;
-    const centerX = (viewBox[2] + viewBox[0]) / 2;
-    const centerY = (viewBox[3] + viewBox[1]) / 2;
-    let rotateA, rotateB, rotateC, rotateD;
+    var centerX = (viewBox[2] + viewBox[0]) / 2;
+    var centerY = (viewBox[3] + viewBox[1]) / 2;
+    var rotateA, rotateB, rotateC, rotateD;
     rotation = rotation % 360;
     rotation = rotation < 0 ? rotation + 360 : rotation;
 
@@ -604,8 +752,8 @@ class PageViewport {
       rotateD = -rotateD;
     }
 
-    let offsetCanvasX, offsetCanvasY;
-    let width, height;
+    var offsetCanvasX, offsetCanvasY;
+    var width, height;
 
     if (rotateA === 0) {
       offsetCanvasX = Math.abs(centerY - viewBox[1]) * scale + offsetX;
@@ -624,53 +772,76 @@ class PageViewport {
     this.height = height;
   }
 
-  clone({
-    scale = this.scale,
-    rotation = this.rotation,
-    offsetX = this.offsetX,
-    offsetY = this.offsetY,
-    dontFlip = false
-  } = {}) {
-    return new PageViewport({
-      viewBox: this.viewBox.slice(),
-      scale,
-      rotation,
-      offsetX,
-      offsetY,
-      dontFlip
-    });
-  }
+  _createClass(PageViewport, [{
+    key: "clone",
+    value: function clone() {
+      var _ref6 = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {},
+          _ref6$scale = _ref6.scale,
+          scale = _ref6$scale === void 0 ? this.scale : _ref6$scale,
+          _ref6$rotation = _ref6.rotation,
+          rotation = _ref6$rotation === void 0 ? this.rotation : _ref6$rotation,
+          _ref6$offsetX = _ref6.offsetX,
+          offsetX = _ref6$offsetX === void 0 ? this.offsetX : _ref6$offsetX,
+          _ref6$offsetY = _ref6.offsetY,
+          offsetY = _ref6$offsetY === void 0 ? this.offsetY : _ref6$offsetY,
+          _ref6$dontFlip = _ref6.dontFlip,
+          dontFlip = _ref6$dontFlip === void 0 ? false : _ref6$dontFlip;
+
+      return new PageViewport({
+        viewBox: this.viewBox.slice(),
+        scale: scale,
+        rotation: rotation,
+        offsetX: offsetX,
+        offsetY: offsetY,
+        dontFlip: dontFlip
+      });
+    }
+  }, {
+    key: "convertToViewportPoint",
+    value: function convertToViewportPoint(x, y) {
+      return _util.Util.applyTransform([x, y], this.transform);
+    }
+  }, {
+    key: "convertToViewportRectangle",
+    value: function convertToViewportRectangle(rect) {
+      var topLeft = _util.Util.applyTransform([rect[0], rect[1]], this.transform);
 
-  convertToViewportPoint(x, y) {
-    return _util.Util.applyTransform([x, y], this.transform);
-  }
+      var bottomRight = _util.Util.applyTransform([rect[2], rect[3]], this.transform);
 
-  convertToViewportRectangle(rect) {
-    const topLeft = _util.Util.applyTransform([rect[0], rect[1]], this.transform);
+      return [topLeft[0], topLeft[1], bottomRight[0], bottomRight[1]];
+    }
+  }, {
+    key: "convertToPdfPoint",
+    value: function convertToPdfPoint(x, y) {
+      return _util.Util.applyInverseTransform([x, y], this.transform);
+    }
+  }]);
 
-    const bottomRight = _util.Util.applyTransform([rect[2], rect[3]], this.transform);
+  return PageViewport;
+}();
 
-    return [topLeft[0], topLeft[1], bottomRight[0], bottomRight[1]];
-  }
+exports.PageViewport = PageViewport;
 
-  convertToPdfPoint(x, y) {
-    return _util.Util.applyInverseTransform([x, y], this.transform);
-  }
+var RenderingCancelledException = /*#__PURE__*/function (_BaseException) {
+  _inherits(RenderingCancelledException, _BaseException);
 
-}
+  var _super = _createSuper(RenderingCancelledException);
 
-exports.PageViewport = PageViewport;
+  function RenderingCancelledException(msg, type) {
+    var _this2;
+
+    _classCallCheck(this, RenderingCancelledException);
 
-class RenderingCancelledException extends _util.BaseException {
-  constructor(msg, type) {
-    super(msg);
-    this.type = type;
+    _this2 = _super.call(this, msg);
+    _this2.type = type;
+    return _this2;
   }
 
-}
+  return RenderingCancelledException;
+}(_util.BaseException);
 
 exports.RenderingCancelledException = RenderingCancelledException;
-const LinkTarget = {
+var LinkTarget = {
   NONE: 0,
   SELF: 1,
   BLANK: 2,
@@ -679,27 +850,29 @@ const LinkTarget = {
 };
 exports.LinkTarget = LinkTarget;
 
-function addLinkAttributes(link, {
-  url,
-  target,
-  rel,
-  enabled = true
-} = {}) {
+function addLinkAttributes(link) {
+  var _ref7 = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {},
+      url = _ref7.url,
+      target = _ref7.target,
+      rel = _ref7.rel,
+      _ref7$enabled = _ref7.enabled,
+      enabled = _ref7$enabled === void 0 ? true : _ref7$enabled;
+
   (0, _util.assert)(url && typeof url === "string", 'addLinkAttributes: A valid "url" parameter must provided.');
-  const urlNullRemoved = (0, _util.removeNullCharacters)(url);
+  var urlNullRemoved = (0, _util.removeNullCharacters)(url);
 
   if (enabled) {
     link.href = link.title = urlNullRemoved;
   } else {
     link.href = "";
-    link.title = `Disabled: ${urlNullRemoved}`;
+    link.title = "Disabled: ".concat(urlNullRemoved);
 
-    link.onclick = () => {
+    link.onclick = function () {
       return false;
     };
   }
 
-  let targetStr = "";
+  var targetStr = "";
 
   switch (target) {
     case LinkTarget.NONE:
@@ -727,60 +900,88 @@ function addLinkAttributes(link, {
 }
 
 function getFilenameFromUrl(url) {
-  const anchor = url.indexOf("#");
-  const query = url.indexOf("?");
-  const end = Math.min(anchor > 0 ? anchor : url.length, query > 0 ? query : url.length);
+  var anchor = url.indexOf("#");
+  var query = url.indexOf("?");
+  var end = Math.min(anchor > 0 ? anchor : url.length, query > 0 ? query : url.length);
   return url.substring(url.lastIndexOf("/", end) + 1, end);
 }
 
-class StatTimer {
-  constructor() {
+var StatTimer = /*#__PURE__*/function () {
+  function StatTimer() {
+    _classCallCheck(this, StatTimer);
+
     this.started = Object.create(null);
     this.times = [];
   }
 
-  time(name) {
-    if (name in this.started) {
-      (0, _util.warn)(`Timer is already running for ${name}`);
-    }
+  _createClass(StatTimer, [{
+    key: "time",
+    value: function time(name) {
+      if (name in this.started) {
+        (0, _util.warn)("Timer is already running for ".concat(name));
+      }
 
-    this.started[name] = Date.now();
-  }
+      this.started[name] = Date.now();
+    }
+  }, {
+    key: "timeEnd",
+    value: function timeEnd(name) {
+      if (!(name in this.started)) {
+        (0, _util.warn)("Timer has not been started for ".concat(name));
+      }
 
-  timeEnd(name) {
-    if (!(name in this.started)) {
-      (0, _util.warn)(`Timer has not been started for ${name}`);
+      this.times.push({
+        name: name,
+        start: this.started[name],
+        end: Date.now()
+      });
+      delete this.started[name];
     }
+  }, {
+    key: "toString",
+    value: function toString() {
+      var outBuf = [];
+      var longest = 0;
 
-    this.times.push({
-      name,
-      start: this.started[name],
-      end: Date.now()
-    });
-    delete this.started[name];
-  }
+      var _iterator = _createForOfIteratorHelper(this.times),
+          _step;
 
-  toString() {
-    const outBuf = [];
-    let longest = 0;
+      try {
+        for (_iterator.s(); !(_step = _iterator.n()).done;) {
+          var time = _step.value;
+          var name = time.name;
 
-    for (const time of this.times) {
-      const name = time.name;
+          if (name.length > longest) {
+            longest = name.length;
+          }
+        }
+      } catch (err) {
+        _iterator.e(err);
+      } finally {
+        _iterator.f();
+      }
+
+      var _iterator2 = _createForOfIteratorHelper(this.times),
+          _step2;
 
-      if (name.length > longest) {
-        longest = name.length;
+      try {
+        for (_iterator2.s(); !(_step2 = _iterator2.n()).done;) {
+          var _time = _step2.value;
+          var duration = _time.end - _time.start;
+          outBuf.push("".concat(_time.name.padEnd(longest), " ").concat(duration, "ms\n"));
+        }
+      } catch (err) {
+        _iterator2.e(err);
+      } finally {
+        _iterator2.f();
       }
-    }
 
-    for (const time of this.times) {
-      const duration = time.end - time.start;
-      outBuf.push(`${time.name.padEnd(longest)} ${duration}ms\n`);
+      return outBuf.join("");
     }
+  }]);
 
-    return outBuf.join("");
-  }
-
-}
+  return StatTimer;
+}();
 
 exports.StatTimer = StatTimer;
 
@@ -790,9 +991,9 @@ function isFetchSupported() {
 
 function isValidFetchUrl(url, baseUrl) {
   try {
-    const {
-      protocol
-    } = baseUrl ? new URL(url, baseUrl) : new URL(url);
+    var _ref8 = baseUrl ? new URL(url, baseUrl) : new URL(url),
+        protocol = _ref8.protocol;
+
     return protocol === "http:" || protocol === "https:";
   } catch (ex) {
     return false;
@@ -800,13 +1001,13 @@ function isValidFetchUrl(url, baseUrl) {
 }
 
 function loadScript(src) {
-  return new Promise((resolve, reject) => {
-    const script = document.createElement("script");
+  return new Promise(function (resolve, reject) {
+    var script = document.createElement("script");
     script.src = src;
     script.onload = resolve;
 
     script.onerror = function () {
-      reject(new Error(`Cannot load script at: ${script.src}`));
+      reject(new Error("Cannot load script at: ".concat(script.src)));
     };
 
     (document.head || document.documentElement).appendChild(script);
@@ -817,58 +1018,688 @@ function deprecated(details) {
   console.log("Deprecated API usage: " + details);
 }
 
-let pdfDateStringRegex;
+var pdfDateStringRegex;
 
-class PDFDateString {
-  static toDateObject(input) {
-    if (!input || !(0, _util.isString)(input)) {
-      return null;
+var PDFDateString = /*#__PURE__*/function () {
+  function PDFDateString() {
+    _classCallCheck(this, PDFDateString);
+  }
+
+  _createClass(PDFDateString, null, [{
+    key: "toDateObject",
+    value: function toDateObject(input) {
+      if (!input || !(0, _util.isString)(input)) {
+        return null;
+      }
+
+      if (!pdfDateStringRegex) {
+        pdfDateStringRegex = new RegExp("^D:" + "(\\d{4})" + "(\\d{2})?" + "(\\d{2})?" + "(\\d{2})?" + "(\\d{2})?" + "(\\d{2})?" + "([Z|+|-])?" + "(\\d{2})?" + "'?" + "(\\d{2})?" + "'?");
+      }
+
+      var matches = pdfDateStringRegex.exec(input);
+
+      if (!matches) {
+        return null;
+      }
+
+      var year = parseInt(matches[1], 10);
+      var month = parseInt(matches[2], 10);
+      month = month >= 1 && month <= 12 ? month - 1 : 0;
+      var day = parseInt(matches[3], 10);
+      day = day >= 1 && day <= 31 ? day : 1;
+      var hour = parseInt(matches[4], 10);
+      hour = hour >= 0 && hour <= 23 ? hour : 0;
+      var minute = parseInt(matches[5], 10);
+      minute = minute >= 0 && minute <= 59 ? minute : 0;
+      var second = parseInt(matches[6], 10);
+      second = second >= 0 && second <= 59 ? second : 0;
+      var universalTimeRelation = matches[7] || "Z";
+      var offsetHour = parseInt(matches[8], 10);
+      offsetHour = offsetHour >= 0 && offsetHour <= 23 ? offsetHour : 0;
+      var offsetMinute = parseInt(matches[9], 10) || 0;
+      offsetMinute = offsetMinute >= 0 && offsetMinute <= 59 ? offsetMinute : 0;
+
+      if (universalTimeRelation === "-") {
+        hour += offsetHour;
+        minute += offsetMinute;
+      } else if (universalTimeRelation === "+") {
+        hour -= offsetHour;
+        minute -= offsetMinute;
+      }
+
+      return new Date(Date.UTC(year, month, day, hour, minute, second));
+    }
+  }]);
+
+  return PDFDateString;
+}();
+
+exports.PDFDateString = PDFDateString;
+
+/***/ }),
+/* 2 */
+/***/ (function(module, exports, __w_pdfjs_require__) {
+
+"use strict";
+
+
+module.exports = __w_pdfjs_require__(3);
+
+/***/ }),
+/* 3 */
+/***/ (function(module, exports, __w_pdfjs_require__) {
+
+"use strict";
+/* WEBPACK VAR INJECTION */(function(module) {
+
+function _typeof(obj) { "@babel/helpers - typeof"; 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); }
+
+var runtime = function (exports) {
+  "use strict";
+
+  var Op = Object.prototype;
+  var hasOwn = Op.hasOwnProperty;
+  var undefined;
+  var $Symbol = typeof Symbol === "function" ? Symbol : {};
+  var iteratorSymbol = $Symbol.iterator || "@@iterator";
+  var asyncIteratorSymbol = $Symbol.asyncIterator || "@@asyncIterator";
+  var toStringTagSymbol = $Symbol.toStringTag || "@@toStringTag";
+
+  function wrap(innerFn, outerFn, self, tryLocsList) {
+    var protoGenerator = outerFn && outerFn.prototype instanceof Generator ? outerFn : Generator;
+    var generator = Object.create(protoGenerator.prototype);
+    var context = new Context(tryLocsList || []);
+    generator._invoke = makeInvokeMethod(innerFn, self, context);
+    return generator;
+  }
+
+  exports.wrap = wrap;
+
+  function tryCatch(fn, obj, arg) {
+    try {
+      return {
+        type: "normal",
+        arg: fn.call(obj, arg)
+      };
+    } catch (err) {
+      return {
+        type: "throw",
+        arg: err
+      };
     }
+  }
+
+  var GenStateSuspendedStart = "suspendedStart";
+  var GenStateSuspendedYield = "suspendedYield";
+  var GenStateExecuting = "executing";
+  var GenStateCompleted = "completed";
+  var ContinueSentinel = {};
+
+  function Generator() {}
+
+  function GeneratorFunction() {}
+
+  function GeneratorFunctionPrototype() {}
+
+  var IteratorPrototype = {};
+
+  IteratorPrototype[iteratorSymbol] = function () {
+    return this;
+  };
+
+  var getProto = Object.getPrototypeOf;
+  var NativeIteratorPrototype = getProto && getProto(getProto(values([])));
+
+  if (NativeIteratorPrototype && NativeIteratorPrototype !== Op && hasOwn.call(NativeIteratorPrototype, iteratorSymbol)) {
+    IteratorPrototype = NativeIteratorPrototype;
+  }
+
+  var Gp = GeneratorFunctionPrototype.prototype = Generator.prototype = Object.create(IteratorPrototype);
+  GeneratorFunction.prototype = Gp.constructor = GeneratorFunctionPrototype;
+  GeneratorFunctionPrototype.constructor = GeneratorFunction;
+  GeneratorFunctionPrototype[toStringTagSymbol] = GeneratorFunction.displayName = "GeneratorFunction";
+
+  function defineIteratorMethods(prototype) {
+    ["next", "throw", "return"].forEach(function (method) {
+      prototype[method] = function (arg) {
+        return this._invoke(method, arg);
+      };
+    });
+  }
+
+  exports.isGeneratorFunction = function (genFun) {
+    var ctor = typeof genFun === "function" && genFun.constructor;
+    return ctor ? ctor === GeneratorFunction || (ctor.displayName || ctor.name) === "GeneratorFunction" : false;
+  };
+
+  exports.mark = function (genFun) {
+    if (Object.setPrototypeOf) {
+      Object.setPrototypeOf(genFun, GeneratorFunctionPrototype);
+    } else {
+      genFun.__proto__ = GeneratorFunctionPrototype;
 
-    if (!pdfDateStringRegex) {
-      pdfDateStringRegex = new RegExp("^D:" + "(\\d{4})" + "(\\d{2})?" + "(\\d{2})?" + "(\\d{2})?" + "(\\d{2})?" + "(\\d{2})?" + "([Z|+|-])?" + "(\\d{2})?" + "'?" + "(\\d{2})?" + "'?");
+      if (!(toStringTagSymbol in genFun)) {
+        genFun[toStringTagSymbol] = "GeneratorFunction";
+      }
     }
 
-    const matches = pdfDateStringRegex.exec(input);
+    genFun.prototype = Object.create(Gp);
+    return genFun;
+  };
 
-    if (!matches) {
-      return null;
+  exports.awrap = function (arg) {
+    return {
+      __await: arg
+    };
+  };
+
+  function AsyncIterator(generator, PromiseImpl) {
+    function invoke(method, arg, resolve, reject) {
+      var record = tryCatch(generator[method], generator, arg);
+
+      if (record.type === "throw") {
+        reject(record.arg);
+      } else {
+        var result = record.arg;
+        var value = result.value;
+
+        if (value && _typeof(value) === "object" && hasOwn.call(value, "__await")) {
+          return PromiseImpl.resolve(value.__await).then(function (value) {
+            invoke("next", value, resolve, reject);
+          }, function (err) {
+            invoke("throw", err, resolve, reject);
+          });
+        }
+
+        return PromiseImpl.resolve(value).then(function (unwrapped) {
+          result.value = unwrapped;
+          resolve(result);
+        }, function (error) {
+          return invoke("throw", error, resolve, reject);
+        });
+      }
     }
 
-    const year = parseInt(matches[1], 10);
-    let month = parseInt(matches[2], 10);
-    month = month >= 1 && month <= 12 ? month - 1 : 0;
-    let day = parseInt(matches[3], 10);
-    day = day >= 1 && day <= 31 ? day : 1;
-    let hour = parseInt(matches[4], 10);
-    hour = hour >= 0 && hour <= 23 ? hour : 0;
-    let minute = parseInt(matches[5], 10);
-    minute = minute >= 0 && minute <= 59 ? minute : 0;
-    let second = parseInt(matches[6], 10);
-    second = second >= 0 && second <= 59 ? second : 0;
-    const universalTimeRelation = matches[7] || "Z";
-    let offsetHour = parseInt(matches[8], 10);
-    offsetHour = offsetHour >= 0 && offsetHour <= 23 ? offsetHour : 0;
-    let offsetMinute = parseInt(matches[9], 10) || 0;
-    offsetMinute = offsetMinute >= 0 && offsetMinute <= 59 ? offsetMinute : 0;
+    var previousPromise;
+
+    function enqueue(method, arg) {
+      function callInvokeWithMethodAndArg() {
+        return new PromiseImpl(function (resolve, reject) {
+          invoke(method, arg, resolve, reject);
+        });
+      }
 
-    if (universalTimeRelation === "-") {
-      hour += offsetHour;
-      minute += offsetMinute;
-    } else if (universalTimeRelation === "+") {
-      hour -= offsetHour;
-      minute -= offsetMinute;
+      return previousPromise = previousPromise ? previousPromise.then(callInvokeWithMethodAndArg, callInvokeWithMethodAndArg) : callInvokeWithMethodAndArg();
     }
 
-    return new Date(Date.UTC(year, month, day, hour, minute, second));
+    this._invoke = enqueue;
   }
 
+  defineIteratorMethods(AsyncIterator.prototype);
+
+  AsyncIterator.prototype[asyncIteratorSymbol] = function () {
+    return this;
+  };
+
+  exports.AsyncIterator = AsyncIterator;
+
+  exports.async = function (innerFn, outerFn, self, tryLocsList, PromiseImpl) {
+    if (PromiseImpl === void 0) PromiseImpl = Promise;
+    var iter = new AsyncIterator(wrap(innerFn, outerFn, self, tryLocsList), PromiseImpl);
+    return exports.isGeneratorFunction(outerFn) ? iter : iter.next().then(function (result) {
+      return result.done ? result.value : iter.next();
+    });
+  };
+
+  function makeInvokeMethod(innerFn, self, context) {
+    var state = GenStateSuspendedStart;
+    return function invoke(method, arg) {
+      if (state === GenStateExecuting) {
+        throw new Error("Generator is already running");
+      }
+
+      if (state === GenStateCompleted) {
+        if (method === "throw") {
+          throw arg;
+        }
+
+        return doneResult();
+      }
+
+      context.method = method;
+      context.arg = arg;
+
+      while (true) {
+        var delegate = context.delegate;
+
+        if (delegate) {
+          var delegateResult = maybeInvokeDelegate(delegate, context);
+
+          if (delegateResult) {
+            if (delegateResult === ContinueSentinel) continue;
+            return delegateResult;
+          }
+        }
+
+        if (context.method === "next") {
+          context.sent = context._sent = context.arg;
+        } else if (context.method === "throw") {
+          if (state === GenStateSuspendedStart) {
+            state = GenStateCompleted;
+            throw context.arg;
+          }
+
+          context.dispatchException(context.arg);
+        } else if (context.method === "return") {
+          context.abrupt("return", context.arg);
+        }
+
+        state = GenStateExecuting;
+        var record = tryCatch(innerFn, self, context);
+
+        if (record.type === "normal") {
+          state = context.done ? GenStateCompleted : GenStateSuspendedYield;
+
+          if (record.arg === ContinueSentinel) {
+            continue;
+          }
+
+          return {
+            value: record.arg,
+            done: context.done
+          };
+        } else if (record.type === "throw") {
+          state = GenStateCompleted;
+          context.method = "throw";
+          context.arg = record.arg;
+        }
+      }
+    };
+  }
+
+  function maybeInvokeDelegate(delegate, context) {
+    var method = delegate.iterator[context.method];
+
+    if (method === undefined) {
+      context.delegate = null;
+
+      if (context.method === "throw") {
+        if (delegate.iterator["return"]) {
+          context.method = "return";
+          context.arg = undefined;
+          maybeInvokeDelegate(delegate, context);
+
+          if (context.method === "throw") {
+            return ContinueSentinel;
+          }
+        }
+
+        context.method = "throw";
+        context.arg = new TypeError("The iterator does not provide a 'throw' method");
+      }
+
+      return ContinueSentinel;
+    }
+
+    var record = tryCatch(method, delegate.iterator, context.arg);
+
+    if (record.type === "throw") {
+      context.method = "throw";
+      context.arg = record.arg;
+      context.delegate = null;
+      return ContinueSentinel;
+    }
+
+    var info = record.arg;
+
+    if (!info) {
+      context.method = "throw";
+      context.arg = new TypeError("iterator result is not an object");
+      context.delegate = null;
+      return ContinueSentinel;
+    }
+
+    if (info.done) {
+      context[delegate.resultName] = info.value;
+      context.next = delegate.nextLoc;
+
+      if (context.method !== "return") {
+        context.method = "next";
+        context.arg = undefined;
+      }
+    } else {
+      return info;
+    }
+
+    context.delegate = null;
+    return ContinueSentinel;
+  }
+
+  defineIteratorMethods(Gp);
+  Gp[toStringTagSymbol] = "Generator";
+
+  Gp[iteratorSymbol] = function () {
+    return this;
+  };
+
+  Gp.toString = function () {
+    return "[object Generator]";
+  };
+
+  function pushTryEntry(locs) {
+    var entry = {
+      tryLoc: locs[0]
+    };
+
+    if (1 in locs) {
+      entry.catchLoc = locs[1];
+    }
+
+    if (2 in locs) {
+      entry.finallyLoc = locs[2];
+      entry.afterLoc = locs[3];
+    }
+
+    this.tryEntries.push(entry);
+  }
+
+  function resetTryEntry(entry) {
+    var record = entry.completion || {};
+    record.type = "normal";
+    delete record.arg;
+    entry.completion = record;
+  }
+
+  function Context(tryLocsList) {
+    this.tryEntries = [{
+      tryLoc: "root"
+    }];
+    tryLocsList.forEach(pushTryEntry, this);
+    this.reset(true);
+  }
+
+  exports.keys = function (object) {
+    var keys = [];
+
+    for (var key in object) {
+      keys.push(key);
+    }
+
+    keys.reverse();
+    return function next() {
+      while (keys.length) {
+        var key = keys.pop();
+
+        if (key in object) {
+          next.value = key;
+          next.done = false;
+          return next;
+        }
+      }
+
+      next.done = true;
+      return next;
+    };
+  };
+
+  function values(iterable) {
+    if (iterable) {
+      var iteratorMethod = iterable[iteratorSymbol];
+
+      if (iteratorMethod) {
+        return iteratorMethod.call(iterable);
+      }
+
+      if (typeof iterable.next === "function") {
+        return iterable;
+      }
+
+      if (!isNaN(iterable.length)) {
+        var i = -1,
+            next = function next() {
+          while (++i < iterable.length) {
+            if (hasOwn.call(iterable, i)) {
+              next.value = iterable[i];
+              next.done = false;
+              return next;
+            }
+          }
+
+          next.value = undefined;
+          next.done = true;
+          return next;
+        };
+
+        return next.next = next;
+      }
+    }
+
+    return {
+      next: doneResult
+    };
+  }
+
+  exports.values = values;
+
+  function doneResult() {
+    return {
+      value: undefined,
+      done: true
+    };
+  }
+
+  Context.prototype = {
+    constructor: Context,
+    reset: function reset(skipTempReset) {
+      this.prev = 0;
+      this.next = 0;
+      this.sent = this._sent = undefined;
+      this.done = false;
+      this.delegate = null;
+      this.method = "next";
+      this.arg = undefined;
+      this.tryEntries.forEach(resetTryEntry);
+
+      if (!skipTempReset) {
+        for (var name in this) {
+          if (name.charAt(0) === "t" && hasOwn.call(this, name) && !isNaN(+name.slice(1))) {
+            this[name] = undefined;
+          }
+        }
+      }
+    },
+    stop: function stop() {
+      this.done = true;
+      var rootEntry = this.tryEntries[0];
+      var rootRecord = rootEntry.completion;
+
+      if (rootRecord.type === "throw") {
+        throw rootRecord.arg;
+      }
+
+      return this.rval;
+    },
+    dispatchException: function dispatchException(exception) {
+      if (this.done) {
+        throw exception;
+      }
+
+      var context = this;
+
+      function handle(loc, caught) {
+        record.type = "throw";
+        record.arg = exception;
+        context.next = loc;
+
+        if (caught) {
+          context.method = "next";
+          context.arg = undefined;
+        }
+
+        return !!caught;
+      }
+
+      for (var i = this.tryEntries.length - 1; i >= 0; --i) {
+        var entry = this.tryEntries[i];
+        var record = entry.completion;
+
+        if (entry.tryLoc === "root") {
+          return handle("end");
+        }
+
+        if (entry.tryLoc <= this.prev) {
+          var hasCatch = hasOwn.call(entry, "catchLoc");
+          var hasFinally = hasOwn.call(entry, "finallyLoc");
+
+          if (hasCatch && hasFinally) {
+            if (this.prev < entry.catchLoc) {
+              return handle(entry.catchLoc, true);
+            } else if (this.prev < entry.finallyLoc) {
+              return handle(entry.finallyLoc);
+            }
+          } else if (hasCatch) {
+            if (this.prev < entry.catchLoc) {
+              return handle(entry.catchLoc, true);
+            }
+          } else if (hasFinally) {
+            if (this.prev < entry.finallyLoc) {
+              return handle(entry.finallyLoc);
+            }
+          } else {
+            throw new Error("try statement without catch or finally");
+          }
+        }
+      }
+    },
+    abrupt: function abrupt(type, arg) {
+      for (var i = this.tryEntries.length - 1; i >= 0; --i) {
+        var entry = this.tryEntries[i];
+
+        if (entry.tryLoc <= this.prev && hasOwn.call(entry, "finallyLoc") && this.prev < entry.finallyLoc) {
+          var finallyEntry = entry;
+          break;
+        }
+      }
+
+      if (finallyEntry && (type === "break" || type === "continue") && finallyEntry.tryLoc <= arg && arg <= finallyEntry.finallyLoc) {
+        finallyEntry = null;
+      }
+
+      var record = finallyEntry ? finallyEntry.completion : {};
+      record.type = type;
+      record.arg = arg;
+
+      if (finallyEntry) {
+        this.method = "next";
+        this.next = finallyEntry.finallyLoc;
+        return ContinueSentinel;
+      }
+
+      return this.complete(record);
+    },
+    complete: function complete(record, afterLoc) {
+      if (record.type === "throw") {
+        throw record.arg;
+      }
+
+      if (record.type === "break" || record.type === "continue") {
+        this.next = record.arg;
+      } else if (record.type === "return") {
+        this.rval = this.arg = record.arg;
+        this.method = "return";
+        this.next = "end";
+      } else if (record.type === "normal" && afterLoc) {
+        this.next = afterLoc;
+      }
+
+      return ContinueSentinel;
+    },
+    finish: function finish(finallyLoc) {
+      for (var i = this.tryEntries.length - 1; i >= 0; --i) {
+        var entry = this.tryEntries[i];
+
+        if (entry.finallyLoc === finallyLoc) {
+          this.complete(entry.completion, entry.afterLoc);
+          resetTryEntry(entry);
+          return ContinueSentinel;
+        }
+      }
+    },
+    "catch": function _catch(tryLoc) {
+      for (var i = this.tryEntries.length - 1; i >= 0; --i) {
+        var entry = this.tryEntries[i];
+
+        if (entry.tryLoc === tryLoc) {
+          var record = entry.completion;
+
+          if (record.type === "throw") {
+            var thrown = record.arg;
+            resetTryEntry(entry);
+          }
+
+          return thrown;
+        }
+      }
+
+      throw new Error("illegal catch attempt");
+    },
+    delegateYield: function delegateYield(iterable, resultName, nextLoc) {
+      this.delegate = {
+        iterator: values(iterable),
+        resultName: resultName,
+        nextLoc: nextLoc
+      };
+
+      if (this.method === "next") {
+        this.arg = undefined;
+      }
+
+      return ContinueSentinel;
+    }
+  };
+  return exports;
+}(( false ? undefined : _typeof(module)) === "object" ? module.exports : {});
+
+try {
+  regeneratorRuntime = runtime;
+} catch (accidentalStrictMode) {
+  Function("r", "regeneratorRuntime = r")(runtime);
 }
+/* WEBPACK VAR INJECTION */}.call(this, __w_pdfjs_require__(4)(module)))
 
-exports.PDFDateString = PDFDateString;
+/***/ }),
+/* 4 */
+/***/ (function(module, exports, __w_pdfjs_require__) {
+
+"use strict";
+
+
+module.exports = function (module) {
+  if (!module.webpackPolyfill) {
+    module.deprecate = function () {};
+
+    module.paths = [];
+    if (!module.children) module.children = [];
+    Object.defineProperty(module, "loaded", {
+      enumerable: true,
+      get: function get() {
+        return module.l;
+      }
+    });
+    Object.defineProperty(module, "id", {
+      enumerable: true,
+      get: function get() {
+        return module.i;
+      }
+    });
+    module.webpackPolyfill = 1;
+  }
+
+  return module;
+};
 
 /***/ }),
-/* 2 */
+/* 5 */
 /***/ (function(module, exports, __w_pdfjs_require__) {
 
 "use strict";
@@ -904,13 +1735,35 @@ exports.warn = warn;
 exports.unreachable = unreachable;
 exports.IsEvalSupportedCached = exports.IsLittleEndianCached = exports.createObjectURL = exports.FormatError = exports.Util = exports.UnknownErrorException = exports.UnexpectedResponseException = exports.TextRenderingMode = exports.StreamType = exports.PermissionFlag = exports.PasswordResponses = exports.PasswordException = exports.MissingPDFException = exports.InvalidPDFException = exports.AbortException = exports.CMapCompressionType = exports.ImageKind = exports.FontType = exports.AnnotationType = exports.AnnotationStateModelType = exports.AnnotationReviewState = exports.AnnotationReplyType = exports.AnnotationMarkedState = exports.AnnotationFlag = exports.AnnotationFieldFlag = exports.AnnotationBorderStyleType = exports.UNSUPPORTED_FEATURES = exports.VerbosityLevel = exports.OPS = exports.IDENTITY_MATRIX = exports.FONT_IDENTITY_MATRIX = exports.BaseException = void 0;
 
-__w_pdfjs_require__(3);
+__w_pdfjs_require__(6);
+
+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; }
+
+function _typeof(obj) { "@babel/helpers - typeof"; if (typeof Symbol === "function" && typeof Symbol.iterator === "symbol") { _typeof = function _typeof(obj) { return typeof obj; }; } else { _typeof = function _typeof(obj) { return obj && typeof Symbol === "function" && obj.constructor === Symbol && obj !== Symbol.prototype ? "symbol" : typeof obj; }; } return _typeof(obj); }
+
+function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }
+
+function _inherits(subClass, superClass) { if (typeof superClass !== "function" && superClass !== null) { throw new TypeError("Super expression must either be null or a function"); } subClass.prototype = Object.create(superClass && superClass.prototype, { constructor: { value: subClass, writable: true, configurable: true } }); if (superClass) _setPrototypeOf(subClass, superClass); }
 
-const IDENTITY_MATRIX = [1, 0, 0, 1, 0, 0];
+function _setPrototypeOf(o, p) { _setPrototypeOf = Object.setPrototypeOf || function _setPrototypeOf(o, p) { o.__proto__ = p; return o; }; return _setPrototypeOf(o, p); }
+
+function _createSuper(Derived) { var hasNativeReflectConstruct = _isNativeReflectConstruct(); return function _createSuperInternal() { var Super = _getPrototypeOf(Derived), result; if (hasNativeReflectConstruct) { var NewTarget = _getPrototypeOf(this).constructor; result = Reflect.construct(Super, arguments, NewTarget); } else { result = Super.apply(this, arguments); } return _possibleConstructorReturn(this, result); }; }
+
+function _possibleConstructorReturn(self, call) { if (call && (_typeof(call) === "object" || typeof call === "function")) { return call; } return _assertThisInitialized(self); }
+
+function _assertThisInitialized(self) { if (self === void 0) { throw new ReferenceError("this hasn't been initialised - super() hasn't been called"); } return self; }
+
+function _isNativeReflectConstruct() { if (typeof Reflect === "undefined" || !Reflect.construct) return false; if (Reflect.construct.sham) return false; if (typeof Proxy === "function") return true; try { Date.prototype.toString.call(Reflect.construct(Date, [], function () {})); return true; } catch (e) { return false; } }
+
+function _getPrototypeOf(o) { _getPrototypeOf = Object.setPrototypeOf ? Object.getPrototypeOf : function _getPrototypeOf(o) { return o.__proto__ || Object.getPrototypeOf(o); }; return _getPrototypeOf(o); }
+
+var IDENTITY_MATRIX = [1, 0, 0, 1, 0, 0];
 exports.IDENTITY_MATRIX = IDENTITY_MATRIX;
-const FONT_IDENTITY_MATRIX = [0.001, 0, 0, 0.001, 0, 0];
+var FONT_IDENTITY_MATRIX = [0.001, 0, 0, 0.001, 0, 0];
 exports.FONT_IDENTITY_MATRIX = FONT_IDENTITY_MATRIX;
-const PermissionFlag = {
+var PermissionFlag = {
   PRINT: 0x04,
   MODIFY_CONTENTS: 0x08,
   COPY: 0x10,
@@ -921,7 +1774,7 @@ const PermissionFlag = {
   PRINT_HIGH_QUALITY: 0x800
 };
 exports.PermissionFlag = PermissionFlag;
-const TextRenderingMode = {
+var TextRenderingMode = {
   FILL: 0,
   STROKE: 1,
   FILL_STROKE: 2,
@@ -934,13 +1787,13 @@ const TextRenderingMode = {
   ADD_TO_PATH_FLAG: 4
 };
 exports.TextRenderingMode = TextRenderingMode;
-const ImageKind = {
+var ImageKind = {
   GRAYSCALE_1BPP: 1,
   RGB_24BPP: 2,
   RGBA_32BPP: 3
 };
 exports.ImageKind = ImageKind;
-const AnnotationType = {
+var AnnotationType = {
   TEXT: 1,
   LINK: 2,
   FREETEXT: 3,
@@ -969,17 +1822,17 @@ const AnnotationType = {
   REDACT: 26
 };
 exports.AnnotationType = AnnotationType;
-const AnnotationStateModelType = {
+var AnnotationStateModelType = {
   MARKED: "Marked",
   REVIEW: "Review"
 };
 exports.AnnotationStateModelType = AnnotationStateModelType;
-const AnnotationMarkedState = {
+var AnnotationMarkedState = {
   MARKED: "Marked",
   UNMARKED: "Unmarked"
 };
 exports.AnnotationMarkedState = AnnotationMarkedState;
-const AnnotationReviewState = {
+var AnnotationReviewState = {
   ACCEPTED: "Accepted",
   REJECTED: "Rejected",
   CANCELLED: "Cancelled",
@@ -987,12 +1840,12 @@ const AnnotationReviewState = {
   NONE: "None"
 };
 exports.AnnotationReviewState = AnnotationReviewState;
-const AnnotationReplyType = {
+var AnnotationReplyType = {
   GROUP: "Group",
   REPLY: "R"
 };
 exports.AnnotationReplyType = AnnotationReplyType;
-const AnnotationFlag = {
+var AnnotationFlag = {
   INVISIBLE: 0x01,
   HIDDEN: 0x02,
   PRINT: 0x04,
@@ -1005,7 +1858,7 @@ const AnnotationFlag = {
   LOCKEDCONTENTS: 0x200
 };
 exports.AnnotationFlag = AnnotationFlag;
-const AnnotationFieldFlag = {
+var AnnotationFieldFlag = {
   READONLY: 0x0000001,
   REQUIRED: 0x0000002,
   NOEXPORT: 0x0000004,
@@ -1027,7 +1880,7 @@ const AnnotationFieldFlag = {
   COMMITONSELCHANGE: 0x4000000
 };
 exports.AnnotationFieldFlag = AnnotationFieldFlag;
-const AnnotationBorderStyleType = {
+var AnnotationBorderStyleType = {
   SOLID: 1,
   DASHED: 2,
   BEVELED: 3,
@@ -1035,7 +1888,7 @@ const AnnotationBorderStyleType = {
   UNDERLINE: 5
 };
 exports.AnnotationBorderStyleType = AnnotationBorderStyleType;
-const StreamType = {
+var StreamType = {
   UNKNOWN: "UNKNOWN",
   FLATE: "FLATE",
   LZW: "LZW",
@@ -1048,7 +1901,7 @@ const StreamType = {
   RLX: "RLX"
 };
 exports.StreamType = StreamType;
-const FontType = {
+var FontType = {
   UNKNOWN: "UNKNOWN",
   TYPE1: "TYPE1",
   TYPE1C: "TYPE1C",
@@ -1062,19 +1915,19 @@ const FontType = {
   MMTYPE1: "MMTYPE1"
 };
 exports.FontType = FontType;
-const VerbosityLevel = {
+var VerbosityLevel = {
   ERRORS: 0,
   WARNINGS: 1,
   INFOS: 5
 };
 exports.VerbosityLevel = VerbosityLevel;
-const CMapCompressionType = {
+var CMapCompressionType = {
   NONE: 0,
   BINARY: 1,
   STREAM: 2
 };
 exports.CMapCompressionType = CMapCompressionType;
-const OPS = {
+var OPS = {
   dependency: 1,
   setLineWidth: 2,
   setLineCap: 3,
@@ -1168,7 +2021,7 @@ const OPS = {
   constructPath: 91
 };
 exports.OPS = OPS;
-const UNSUPPORTED_FEATURES = {
+var UNSUPPORTED_FEATURES = {
   unknown: "unknown",
   forms: "forms",
   javaScript: "javaScript",
@@ -1189,12 +2042,12 @@ const UNSUPPORTED_FEATURES = {
   errorFontGetPath: "errorFontGetPath"
 };
 exports.UNSUPPORTED_FEATURES = UNSUPPORTED_FEATURES;
-const PasswordResponses = {
+var PasswordResponses = {
   NEED_PASSWORD: 1,
   INCORRECT_PASSWORD: 2
 };
 exports.PasswordResponses = PasswordResponses;
-let verbosity = VerbosityLevel.WARNINGS;
+var verbosity = VerbosityLevel.WARNINGS;
 
 function setVerbosityLevel(level) {
   if (Number.isInteger(level)) {
@@ -1208,13 +2061,13 @@ function getVerbosityLevel() {
 
 function info(msg) {
   if (verbosity >= VerbosityLevel.INFOS) {
-    console.log(`Info: ${msg}`);
+    console.log("Info: ".concat(msg));
   }
 }
 
 function warn(msg) {
   if (verbosity >= VerbosityLevel.WARNINGS) {
-    console.log(`Warning: ${msg}`);
+    console.log("Warning: ".concat(msg));
   }
 }
 
@@ -1229,7 +2082,7 @@ function assert(cond, msg) {
 }
 
 function isSameOrigin(baseUrl, otherUrl) {
-  let base;
+  var base;
 
   try {
     base = new URL(baseUrl);
@@ -1241,7 +2094,7 @@ function isSameOrigin(baseUrl, otherUrl) {
     return false;
   }
 
-  const other = new URL(otherUrl, base);
+  var other = new URL(otherUrl, base);
   return base.origin === other.origin;
 }
 
@@ -1269,7 +2122,7 @@ function createValidAbsoluteUrl(url, baseUrl) {
   }
 
   try {
-    const absoluteUrl = baseUrl ? new URL(url, baseUrl) : new URL(url);
+    var absoluteUrl = baseUrl ? new URL(url, baseUrl) : new URL(url);
 
     if (_isValidProtocol(absoluteUrl)) {
       return absoluteUrl;
@@ -1281,7 +2134,7 @@ function createValidAbsoluteUrl(url, baseUrl) {
 
 function shadow(obj, prop, value) {
   Object.defineProperty(obj, prop, {
-    value,
+    value: value,
     enumerable: true,
     configurable: true,
     writable: false
@@ -1289,7 +2142,7 @@ function shadow(obj, prop, value) {
   return value;
 }
 
-const BaseException = function BaseExceptionClosure() {
+var BaseException = function BaseExceptionClosure() {
   function BaseException(message) {
     if (this.constructor === BaseException) {
       unreachable("Cannot initialize BaseException.");
@@ -1306,52 +2159,130 @@ const BaseException = function BaseExceptionClosure() {
 
 exports.BaseException = BaseException;
 
-class PasswordException extends BaseException {
-  constructor(msg, code) {
-    super(msg);
-    this.code = code;
+var PasswordException = /*#__PURE__*/function (_BaseException) {
+  _inherits(PasswordException, _BaseException);
+
+  var _super = _createSuper(PasswordException);
+
+  function PasswordException(msg, code) {
+    var _this;
+
+    _classCallCheck(this, PasswordException);
+
+    _this = _super.call(this, msg);
+    _this.code = code;
+    return _this;
   }
 
-}
+  return PasswordException;
+}(BaseException);
 
 exports.PasswordException = PasswordException;
 
-class UnknownErrorException extends BaseException {
-  constructor(msg, details) {
-    super(msg);
-    this.details = details;
+var UnknownErrorException = /*#__PURE__*/function (_BaseException2) {
+  _inherits(UnknownErrorException, _BaseException2);
+
+  var _super2 = _createSuper(UnknownErrorException);
+
+  function UnknownErrorException(msg, details) {
+    var _this2;
+
+    _classCallCheck(this, UnknownErrorException);
+
+    _this2 = _super2.call(this, msg);
+    _this2.details = details;
+    return _this2;
   }
 
-}
+  return UnknownErrorException;
+}(BaseException);
 
 exports.UnknownErrorException = UnknownErrorException;
 
-class InvalidPDFException extends BaseException {}
+var InvalidPDFException = /*#__PURE__*/function (_BaseException3) {
+  _inherits(InvalidPDFException, _BaseException3);
+
+  var _super3 = _createSuper(InvalidPDFException);
+
+  function InvalidPDFException() {
+    _classCallCheck(this, InvalidPDFException);
+
+    return _super3.apply(this, arguments);
+  }
+
+  return InvalidPDFException;
+}(BaseException);
 
 exports.InvalidPDFException = InvalidPDFException;
 
-class MissingPDFException extends BaseException {}
+var MissingPDFException = /*#__PURE__*/function (_BaseException4) {
+  _inherits(MissingPDFException, _BaseException4);
+
+  var _super4 = _createSuper(MissingPDFException);
+
+  function MissingPDFException() {
+    _classCallCheck(this, MissingPDFException);
+
+    return _super4.apply(this, arguments);
+  }
+
+  return MissingPDFException;
+}(BaseException);
 
 exports.MissingPDFException = MissingPDFException;
 
-class UnexpectedResponseException extends BaseException {
-  constructor(msg, status) {
-    super(msg);
-    this.status = status;
+var UnexpectedResponseException = /*#__PURE__*/function (_BaseException5) {
+  _inherits(UnexpectedResponseException, _BaseException5);
+
+  var _super5 = _createSuper(UnexpectedResponseException);
+
+  function UnexpectedResponseException(msg, status) {
+    var _this3;
+
+    _classCallCheck(this, UnexpectedResponseException);
+
+    _this3 = _super5.call(this, msg);
+    _this3.status = status;
+    return _this3;
   }
 
-}
+  return UnexpectedResponseException;
+}(BaseException);
 
 exports.UnexpectedResponseException = UnexpectedResponseException;
 
-class FormatError extends BaseException {}
+var FormatError = /*#__PURE__*/function (_BaseException6) {
+  _inherits(FormatError, _BaseException6);
+
+  var _super6 = _createSuper(FormatError);
+
+  function FormatError() {
+    _classCallCheck(this, FormatError);
+
+    return _super6.apply(this, arguments);
+  }
+
+  return FormatError;
+}(BaseException);
 
 exports.FormatError = FormatError;
 
-class AbortException extends BaseException {}
+var AbortException = /*#__PURE__*/function (_BaseException7) {
+  _inherits(AbortException, _BaseException7);
+
+  var _super7 = _createSuper(AbortException);
+
+  function AbortException() {
+    _classCallCheck(this, AbortException);
+
+    return _super7.apply(this, arguments);
+  }
+
+  return AbortException;
+}(BaseException);
 
 exports.AbortException = AbortException;
-const NullCharactersRegExp = /\x00/g;
+var NullCharactersRegExp = /\x00/g;
 
 function removeNullCharacters(str) {
   if (typeof str !== "string") {
@@ -1363,19 +2294,19 @@ function removeNullCharacters(str) {
 }
 
 function bytesToString(bytes) {
-  assert(bytes !== null && typeof bytes === "object" && bytes.length !== undefined, "Invalid argument for bytesToString");
-  const length = bytes.length;
-  const MAX_ARGUMENT_COUNT = 8192;
+  assert(bytes !== null && _typeof(bytes) === "object" && bytes.length !== undefined, "Invalid argument for bytesToString");
+  var length = bytes.length;
+  var MAX_ARGUMENT_COUNT = 8192;
 
   if (length < MAX_ARGUMENT_COUNT) {
     return String.fromCharCode.apply(null, bytes);
   }
 
-  const strBuf = [];
+  var strBuf = [];
 
-  for (let i = 0; i < length; i += MAX_ARGUMENT_COUNT) {
-    const chunkEnd = Math.min(i + MAX_ARGUMENT_COUNT, length);
-    const chunk = bytes.subarray(i, chunkEnd);
+  for (var i = 0; i < length; i += MAX_ARGUMENT_COUNT) {
+    var chunkEnd = Math.min(i + MAX_ARGUMENT_COUNT, length);
+    var chunk = bytes.subarray(i, chunkEnd);
     strBuf.push(String.fromCharCode.apply(null, chunk));
   }
 
@@ -1384,10 +2315,10 @@ function bytesToString(bytes) {
 
 function stringToBytes(str) {
   assert(typeof str === "string", "Invalid argument for stringToBytes");
-  const length = str.length;
-  const bytes = new Uint8Array(length);
+  var length = str.length;
+  var bytes = new Uint8Array(length);
 
-  for (let i = 0; i < length; ++i) {
+  for (var i = 0; i < length; ++i) {
     bytes[i] = str.charCodeAt(i) & 0xff;
   }
 
@@ -1404,23 +2335,23 @@ function arrayByteLength(arr) {
 }
 
 function arraysToBytes(arr) {
-  const length = arr.length;
+  var length = arr.length;
 
   if (length === 1 && arr[0] instanceof Uint8Array) {
     return arr[0];
   }
 
-  let resultLength = 0;
+  var resultLength = 0;
 
-  for (let i = 0; i < length; i++) {
+  for (var i = 0; i < length; i++) {
     resultLength += arrayByteLength(arr[i]);
   }
 
-  let pos = 0;
-  const data = new Uint8Array(resultLength);
+  var pos = 0;
+  var data = new Uint8Array(resultLength);
 
-  for (let i = 0; i < length; i++) {
-    let item = arr[i];
+  for (var _i = 0; _i < length; _i++) {
+    var item = arr[_i];
 
     if (!(item instanceof Uint8Array)) {
       if (typeof item === "string") {
@@ -1430,7 +2361,7 @@ function arraysToBytes(arr) {
       }
     }
 
-    const itemLength = item.byteLength;
+    var itemLength = item.byteLength;
     data.set(item, pos);
     pos += itemLength;
   }
@@ -1443,13 +2374,13 @@ function string32(value) {
 }
 
 function isLittleEndian() {
-  const buffer8 = new Uint8Array(4);
+  var buffer8 = new Uint8Array(4);
   buffer8[0] = 1;
-  const view32 = new Uint32Array(buffer8.buffer, 0, 1);
+  var view32 = new Uint32Array(buffer8.buffer, 0, 1);
   return view32[0] === 1;
 }
 
-const IsLittleEndianCached = {
+var IsLittleEndianCached = {
   get value() {
     return shadow(this, "value", isLittleEndian());
   }
@@ -1466,135 +2397,152 @@ function isEvalSupported() {
   }
 }
 
-const IsEvalSupportedCached = {
+var IsEvalSupportedCached = {
   get value() {
     return shadow(this, "value", isEvalSupported());
   }
 
 };
 exports.IsEvalSupportedCached = IsEvalSupportedCached;
-const rgbBuf = ["rgb(", 0, ",", 0, ",", 0, ")"];
-
-class Util {
-  static makeCssRgb(r, g, b) {
-    rgbBuf[1] = r;
-    rgbBuf[3] = g;
-    rgbBuf[5] = b;
-    return rgbBuf.join("");
-  }
-
-  static transform(m1, m2) {
-    return [m1[0] * m2[0] + m1[2] * m2[1], m1[1] * m2[0] + m1[3] * m2[1], m1[0] * m2[2] + m1[2] * m2[3], m1[1] * m2[2] + m1[3] * m2[3], m1[0] * m2[4] + m1[2] * m2[5] + m1[4], m1[1] * m2[4] + m1[3] * m2[5] + m1[5]];
-  }
-
-  static applyTransform(p, m) {
-    const xt = p[0] * m[0] + p[1] * m[2] + m[4];
-    const yt = p[0] * m[1] + p[1] * m[3] + m[5];
-    return [xt, yt];
-  }
-
-  static applyInverseTransform(p, m) {
-    const d = m[0] * m[3] - m[1] * m[2];
-    const xt = (p[0] * m[3] - p[1] * m[2] + m[2] * m[5] - m[4] * m[3]) / d;
-    const yt = (-p[0] * m[1] + p[1] * m[0] + m[4] * m[1] - m[5] * m[0]) / d;
-    return [xt, yt];
-  }
-
-  static getAxialAlignedBoundingBox(r, m) {
-    const p1 = Util.applyTransform(r, m);
-    const p2 = Util.applyTransform(r.slice(2, 4), m);
-    const p3 = Util.applyTransform([r[0], r[3]], m);
-    const p4 = Util.applyTransform([r[2], r[1]], m);
-    return [Math.min(p1[0], p2[0], p3[0], p4[0]), Math.min(p1[1], p2[1], p3[1], p4[1]), Math.max(p1[0], p2[0], p3[0], p4[0]), Math.max(p1[1], p2[1], p3[1], p4[1])];
-  }
-
-  static inverseTransform(m) {
-    const d = m[0] * m[3] - m[1] * m[2];
-    return [m[3] / d, -m[1] / d, -m[2] / d, m[0] / d, (m[2] * m[5] - m[4] * m[3]) / d, (m[4] * m[1] - m[5] * m[0]) / d];
-  }
-
-  static apply3dTransform(m, v) {
-    return [m[0] * v[0] + m[1] * v[1] + m[2] * v[2], m[3] * v[0] + m[4] * v[1] + m[5] * v[2], m[6] * v[0] + m[7] * v[1] + m[8] * v[2]];
-  }
-
-  static singularValueDecompose2dScale(m) {
-    const transpose = [m[0], m[2], m[1], m[3]];
-    const a = m[0] * transpose[0] + m[1] * transpose[2];
-    const b = m[0] * transpose[1] + m[1] * transpose[3];
-    const c = m[2] * transpose[0] + m[3] * transpose[2];
-    const d = m[2] * transpose[1] + m[3] * transpose[3];
-    const first = (a + d) / 2;
-    const second = Math.sqrt((a + d) * (a + d) - 4 * (a * d - c * b)) / 2;
-    const sx = first + second || 1;
-    const sy = first - second || 1;
-    return [Math.sqrt(sx), Math.sqrt(sy)];
-  }
-
-  static normalizeRect(rect) {
-    const r = rect.slice(0);
-
-    if (rect[0] > rect[2]) {
-      r[0] = rect[2];
-      r[2] = rect[0];
-    }
-
-    if (rect[1] > rect[3]) {
-      r[1] = rect[3];
-      r[3] = rect[1];
-    }
-
-    return r;
-  }
-
-  static intersect(rect1, rect2) {
-    function compare(a, b) {
-      return a - b;
-    }
-
-    const orderedX = [rect1[0], rect1[2], rect2[0], rect2[2]].sort(compare);
-    const orderedY = [rect1[1], rect1[3], rect2[1], rect2[3]].sort(compare);
-    const result = [];
-    rect1 = Util.normalizeRect(rect1);
-    rect2 = Util.normalizeRect(rect2);
+var rgbBuf = ["rgb(", 0, ",", 0, ",", 0, ")"];
+
+var Util = /*#__PURE__*/function () {
+  function Util() {
+    _classCallCheck(this, Util);
+  }
+
+  _createClass(Util, null, [{
+    key: "makeCssRgb",
+    value: function makeCssRgb(r, g, b) {
+      rgbBuf[1] = r;
+      rgbBuf[3] = g;
+      rgbBuf[5] = b;
+      return rgbBuf.join("");
+    }
+  }, {
+    key: "transform",
+    value: function transform(m1, m2) {
+      return [m1[0] * m2[0] + m1[2] * m2[1], m1[1] * m2[0] + m1[3] * m2[1], m1[0] * m2[2] + m1[2] * m2[3], m1[1] * m2[2] + m1[3] * m2[3], m1[0] * m2[4] + m1[2] * m2[5] + m1[4], m1[1] * m2[4] + m1[3] * m2[5] + m1[5]];
+    }
+  }, {
+    key: "applyTransform",
+    value: function applyTransform(p, m) {
+      var xt = p[0] * m[0] + p[1] * m[2] + m[4];
+      var yt = p[0] * m[1] + p[1] * m[3] + m[5];
+      return [xt, yt];
+    }
+  }, {
+    key: "applyInverseTransform",
+    value: function applyInverseTransform(p, m) {
+      var d = m[0] * m[3] - m[1] * m[2];
+      var xt = (p[0] * m[3] - p[1] * m[2] + m[2] * m[5] - m[4] * m[3]) / d;
+      var yt = (-p[0] * m[1] + p[1] * m[0] + m[4] * m[1] - m[5] * m[0]) / d;
+      return [xt, yt];
+    }
+  }, {
+    key: "getAxialAlignedBoundingBox",
+    value: function getAxialAlignedBoundingBox(r, m) {
+      var p1 = Util.applyTransform(r, m);
+      var p2 = Util.applyTransform(r.slice(2, 4), m);
+      var p3 = Util.applyTransform([r[0], r[3]], m);
+      var p4 = Util.applyTransform([r[2], r[1]], m);
+      return [Math.min(p1[0], p2[0], p3[0], p4[0]), Math.min(p1[1], p2[1], p3[1], p4[1]), Math.max(p1[0], p2[0], p3[0], p4[0]), Math.max(p1[1], p2[1], p3[1], p4[1])];
+    }
+  }, {
+    key: "inverseTransform",
+    value: function inverseTransform(m) {
+      var d = m[0] * m[3] - m[1] * m[2];
+      return [m[3] / d, -m[1] / d, -m[2] / d, m[0] / d, (m[2] * m[5] - m[4] * m[3]) / d, (m[4] * m[1] - m[5] * m[0]) / d];
+    }
+  }, {
+    key: "apply3dTransform",
+    value: function apply3dTransform(m, v) {
+      return [m[0] * v[0] + m[1] * v[1] + m[2] * v[2], m[3] * v[0] + m[4] * v[1] + m[5] * v[2], m[6] * v[0] + m[7] * v[1] + m[8] * v[2]];
+    }
+  }, {
+    key: "singularValueDecompose2dScale",
+    value: function singularValueDecompose2dScale(m) {
+      var transpose = [m[0], m[2], m[1], m[3]];
+      var a = m[0] * transpose[0] + m[1] * transpose[2];
+      var b = m[0] * transpose[1] + m[1] * transpose[3];
+      var c = m[2] * transpose[0] + m[3] * transpose[2];
+      var d = m[2] * transpose[1] + m[3] * transpose[3];
+      var first = (a + d) / 2;
+      var second = Math.sqrt((a + d) * (a + d) - 4 * (a * d - c * b)) / 2;
+      var sx = first + second || 1;
+      var sy = first - second || 1;
+      return [Math.sqrt(sx), Math.sqrt(sy)];
+    }
+  }, {
+    key: "normalizeRect",
+    value: function normalizeRect(rect) {
+      var r = rect.slice(0);
+
+      if (rect[0] > rect[2]) {
+        r[0] = rect[2];
+        r[2] = rect[0];
+      }
+
+      if (rect[1] > rect[3]) {
+        r[1] = rect[3];
+        r[3] = rect[1];
+      }
+
+      return r;
+    }
+  }, {
+    key: "intersect",
+    value: function intersect(rect1, rect2) {
+      function compare(a, b) {
+        return a - b;
+      }
+
+      var orderedX = [rect1[0], rect1[2], rect2[0], rect2[2]].sort(compare);
+      var orderedY = [rect1[1], rect1[3], rect2[1], rect2[3]].sort(compare);
+      var result = [];
+      rect1 = Util.normalizeRect(rect1);
+      rect2 = Util.normalizeRect(rect2);
+
+      if (orderedX[0] === rect1[0] && orderedX[1] === rect2[0] || orderedX[0] === rect2[0] && orderedX[1] === rect1[0]) {
+        result[0] = orderedX[1];
+        result[2] = orderedX[2];
+      } else {
+        return null;
+      }
 
-    if (orderedX[0] === rect1[0] && orderedX[1] === rect2[0] || orderedX[0] === rect2[0] && orderedX[1] === rect1[0]) {
-      result[0] = orderedX[1];
-      result[2] = orderedX[2];
-    } else {
-      return null;
-    }
+      if (orderedY[0] === rect1[1] && orderedY[1] === rect2[1] || orderedY[0] === rect2[1] && orderedY[1] === rect1[1]) {
+        result[1] = orderedY[1];
+        result[3] = orderedY[2];
+      } else {
+        return null;
+      }
 
-    if (orderedY[0] === rect1[1] && orderedY[1] === rect2[1] || orderedY[0] === rect2[1] && orderedY[1] === rect1[1]) {
-      result[1] = orderedY[1];
-      result[3] = orderedY[2];
-    } else {
-      return null;
+      return result;
     }
+  }]);
 
-    return result;
-  }
-
-}
+  return Util;
+}();
 
 exports.Util = Util;
-const PDFStringTranslateTable = [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0x2D8, 0x2C7, 0x2C6, 0x2D9, 0x2DD, 0x2DB, 0x2DA, 0x2DC, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0x2022, 0x2020, 0x2021, 0x2026, 0x2014, 0x2013, 0x192, 0x2044, 0x2039, 0x203A, 0x2212, 0x2030, 0x201E, 0x201C, 0x201D, 0x2018, 0x2019, 0x201A, 0x2122, 0xFB01, 0xFB02, 0x141, 0x152, 0x160, 0x178, 0x17D, 0x131, 0x142, 0x153, 0x161, 0x17E, 0, 0x20AC];
+var PDFStringTranslateTable = [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0x2D8, 0x2C7, 0x2C6, 0x2D9, 0x2DD, 0x2DB, 0x2DA, 0x2DC, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0x2022, 0x2020, 0x2021, 0x2026, 0x2014, 0x2013, 0x192, 0x2044, 0x2039, 0x203A, 0x2212, 0x2030, 0x201E, 0x201C, 0x201D, 0x2018, 0x2019, 0x201A, 0x2122, 0xFB01, 0xFB02, 0x141, 0x152, 0x160, 0x178, 0x17D, 0x131, 0x142, 0x153, 0x161, 0x17E, 0, 0x20AC];
 
 function stringToPDFString(str) {
-  const length = str.length,
-        strBuf = [];
+  var length = str.length,
+      strBuf = [];
 
   if (str[0] === "\xFE" && str[1] === "\xFF") {
-    for (let i = 2; i < length; i += 2) {
+    for (var i = 2; i < length; i += 2) {
       strBuf.push(String.fromCharCode(str.charCodeAt(i) << 8 | str.charCodeAt(i + 1)));
     }
   } else if (str[0] === "\xFF" && str[1] === "\xFE") {
-    for (let i = 2; i < length; i += 2) {
-      strBuf.push(String.fromCharCode(str.charCodeAt(i + 1) << 8 | str.charCodeAt(i)));
+    for (var _i2 = 2; _i2 < length; _i2 += 2) {
+      strBuf.push(String.fromCharCode(str.charCodeAt(_i2 + 1) << 8 | str.charCodeAt(_i2)));
     }
   } else {
-    for (let i = 0; i < length; ++i) {
-      const code = PDFStringTranslateTable[str.charCodeAt(i)];
-      strBuf.push(code ? String.fromCharCode(code) : str.charAt(i));
+    for (var _i3 = 0; _i3 < length; ++_i3) {
+      var code = PDFStringTranslateTable[str.charCodeAt(_i3)];
+      strBuf.push(code ? String.fromCharCode(code) : str.charAt(_i3));
     }
   }
 
@@ -1610,7 +2558,7 @@ function utf8StringToString(str) {
 }
 
 function isEmptyObj(obj) {
-  for (const key in obj) {
+  for (var key in obj) {
     return false;
   }
 
@@ -1630,7 +2578,7 @@ function isString(v) {
 }
 
 function isArrayBuffer(v) {
-  return typeof v === "object" && v !== null && v.byteLength !== undefined;
+  return _typeof(v) === "object" && v !== null && v.byteLength !== undefined;
 }
 
 function isArrayEqual(arr1, arr2) {
@@ -1644,13 +2592,12 @@ function isArrayEqual(arr1, arr2) {
 }
 
 function createPromiseCapability() {
-  const capability = Object.create(null);
-  let isSettled = false;
+  var capability = Object.create(null);
+  var isSettled = false;
   Object.defineProperty(capability, "settled", {
-    get() {
+    get: function get() {
       return isSettled;
     }
-
   });
   capability.promise = new Promise(function (resolve, reject) {
     capability.resolve = function (data) {
@@ -1666,26 +2613,28 @@ function createPromiseCapability() {
   return capability;
 }
 
-const createObjectURL = function createObjectURLClosure() {
-  const digits = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/=";
-  return function createObjectURL(data, contentType, forceDataSchema = false) {
+var createObjectURL = function createObjectURLClosure() {
+  var digits = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/=";
+  return function createObjectURL(data, contentType) {
+    var forceDataSchema = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : false;
+
     if (!forceDataSchema && URL.createObjectURL) {
-      const blob = new Blob([data], {
+      var blob = new Blob([data], {
         type: contentType
       });
       return URL.createObjectURL(blob);
     }
 
-    let buffer = `data:${contentType};base64,`;
+    var buffer = "data:".concat(contentType, ";base64,");
 
-    for (let i = 0, ii = data.length; i < ii; i += 3) {
-      const b1 = data[i] & 0xff;
-      const b2 = data[i + 1] & 0xff;
-      const b3 = data[i + 2] & 0xff;
-      const d1 = b1 >> 2,
-            d2 = (b1 & 3) << 4 | b2 >> 4;
-      const d3 = i + 1 < ii ? (b2 & 0xf) << 2 | b3 >> 6 : 64;
-      const d4 = i + 2 < ii ? b3 & 0x3f : 64;
+    for (var i = 0, ii = data.length; i < ii; i += 3) {
+      var b1 = data[i] & 0xff;
+      var b2 = data[i + 1] & 0xff;
+      var b3 = data[i + 2] & 0xff;
+      var d1 = b1 >> 2,
+          d2 = (b1 & 3) << 4 | b2 >> 4;
+      var d3 = i + 1 < ii ? (b2 & 0xf) << 2 | b3 >> 6 : 64;
+      var d4 = i + 2 < ii ? b3 & 0x3f : 64;
       buffer += digits[d1] + digits[d2] + digits[d3] + digits[d4];
     }
 
@@ -1696,18 +2645,332 @@ const createObjectURL = function createObjectURLClosure() {
 exports.createObjectURL = createObjectURL;
 
 /***/ }),
-/* 3 */
+/* 6 */
 /***/ (function(module, exports, __w_pdfjs_require__) {
 
 "use strict";
 
 
-var _is_node = __w_pdfjs_require__(4);
+var _is_node = __w_pdfjs_require__(7);
 
-;
+function _typeof(obj) { "@babel/helpers - typeof"; 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); }
+
+if (typeof globalThis === "undefined" || !globalThis._pdfjsCompatibilityChecked) {
+  if (typeof globalThis === "undefined" || globalThis.Math !== Math) {
+    globalThis = __w_pdfjs_require__(8);
+  }
+
+  globalThis._pdfjsCompatibilityChecked = true;
+  var hasDOM = (typeof window === "undefined" ? "undefined" : _typeof(window)) === "object" && (typeof document === "undefined" ? "undefined" : _typeof(document)) === "object";
+  var userAgent = typeof navigator !== "undefined" && navigator.userAgent || "";
+  var isIE = /Trident/.test(userAgent);
+
+  (function checkNodeBtoa() {
+    if (globalThis.btoa || !_is_node.isNodeJS) {
+      return;
+    }
+
+    globalThis.btoa = function (chars) {
+      return Buffer.from(chars, "binary").toString("base64");
+    };
+  })();
+
+  (function checkNodeAtob() {
+    if (globalThis.atob || !_is_node.isNodeJS) {
+      return;
+    }
+
+    globalThis.atob = function (input) {
+      return Buffer.from(input, "base64").toString("binary");
+    };
+  })();
+
+  (function checkChildNodeRemove() {
+    if (!hasDOM) {
+      return;
+    }
+
+    if (typeof Element.prototype.remove !== "undefined") {
+      return;
+    }
+
+    Element.prototype.remove = function () {
+      if (this.parentNode) {
+        this.parentNode.removeChild(this);
+      }
+    };
+  })();
+
+  (function checkDOMTokenListAddRemove() {
+    if (!hasDOM || _is_node.isNodeJS) {
+      return;
+    }
+
+    var div = document.createElement("div");
+    div.classList.add("testOne", "testTwo");
+
+    if (div.classList.contains("testOne") === true && div.classList.contains("testTwo") === true) {
+      return;
+    }
+
+    var OriginalDOMTokenListAdd = DOMTokenList.prototype.add;
+    var OriginalDOMTokenListRemove = DOMTokenList.prototype.remove;
+
+    DOMTokenList.prototype.add = function () {
+      for (var _len = arguments.length, tokens = new Array(_len), _key = 0; _key < _len; _key++) {
+        tokens[_key] = arguments[_key];
+      }
+
+      for (var _i = 0, _tokens = tokens; _i < _tokens.length; _i++) {
+        var token = _tokens[_i];
+        OriginalDOMTokenListAdd.call(this, token);
+      }
+    };
+
+    DOMTokenList.prototype.remove = function () {
+      for (var _len2 = arguments.length, tokens = new Array(_len2), _key2 = 0; _key2 < _len2; _key2++) {
+        tokens[_key2] = arguments[_key2];
+      }
+
+      for (var _i2 = 0, _tokens2 = tokens; _i2 < _tokens2.length; _i2++) {
+        var token = _tokens2[_i2];
+        OriginalDOMTokenListRemove.call(this, token);
+      }
+    };
+  })();
+
+  (function checkDOMTokenListToggle() {
+    if (!hasDOM || _is_node.isNodeJS) {
+      return;
+    }
+
+    var div = document.createElement("div");
+
+    if (div.classList.toggle("test", 0) === false) {
+      return;
+    }
+
+    DOMTokenList.prototype.toggle = function (token) {
+      var force = arguments.length > 1 ? !!arguments[1] : !this.contains(token);
+      return this[force ? "add" : "remove"](token), force;
+    };
+  })();
+
+  (function checkWindowHistoryPushStateReplaceState() {
+    if (!hasDOM || !isIE) {
+      return;
+    }
+
+    var OriginalPushState = window.history.pushState;
+    var OriginalReplaceState = window.history.replaceState;
+
+    window.history.pushState = function (state, title, url) {
+      var args = url === undefined ? [state, title] : [state, title, url];
+      OriginalPushState.apply(this, args);
+    };
+
+    window.history.replaceState = function (state, title, url) {
+      var args = url === undefined ? [state, title] : [state, title, url];
+      OriginalReplaceState.apply(this, args);
+    };
+  })();
+
+  (function checkStringStartsWith() {
+    if (String.prototype.startsWith) {
+      return;
+    }
+
+    __w_pdfjs_require__(53);
+  })();
+
+  (function checkStringEndsWith() {
+    if (String.prototype.endsWith) {
+      return;
+    }
+
+    __w_pdfjs_require__(64);
+  })();
+
+  (function checkStringIncludes() {
+    if (String.prototype.includes) {
+      return;
+    }
+
+    __w_pdfjs_require__(66);
+  })();
+
+  (function checkArrayIncludes() {
+    if (Array.prototype.includes) {
+      return;
+    }
+
+    __w_pdfjs_require__(68);
+  })();
+
+  (function checkArrayFrom() {
+    if (Array.from) {
+      return;
+    }
+
+    __w_pdfjs_require__(76);
+  })();
+
+  (function checkObjectAssign() {
+    if (Object.assign) {
+      return;
+    }
+
+    __w_pdfjs_require__(98);
+  })();
+
+  (function checkMathLog2() {
+    if (Math.log2) {
+      return;
+    }
+
+    Math.log2 = __w_pdfjs_require__(101);
+  })();
+
+  (function checkNumberIsNaN() {
+    if (Number.isNaN) {
+      return;
+    }
+
+    Number.isNaN = __w_pdfjs_require__(103);
+  })();
+
+  (function checkNumberIsInteger() {
+    if (Number.isInteger) {
+      return;
+    }
+
+    Number.isInteger = __w_pdfjs_require__(105);
+  })();
+
+  (function checkTypedArraySlice() {
+    if (Uint8Array.prototype.slice) {
+      return;
+    }
+
+    __w_pdfjs_require__(108);
+  })();
+
+  (function checkPromise() {
+    if (globalThis.Promise && globalThis.Promise.allSettled) {
+      return;
+    }
+
+    globalThis.Promise = __w_pdfjs_require__(113);
+  })();
+
+  (function checkURL() {
+    globalThis.URL = __w_pdfjs_require__(136);
+  })();
+
+  (function checkReadableStream() {
+    var isReadableStreamSupported = false;
+
+    if (typeof ReadableStream !== "undefined") {
+      try {
+        new ReadableStream({
+          start: function start(controller) {
+            controller.close();
+          }
+        });
+        isReadableStreamSupported = true;
+      } catch (e) {}
+    }
+
+    if (isReadableStreamSupported) {
+      return;
+    }
+
+    globalThis.ReadableStream = __w_pdfjs_require__(143).ReadableStream;
+  })();
+
+  (function checkMapEntries() {
+    if (globalThis.Map && globalThis.Map.prototype.entries) {
+      return;
+    }
+
+    globalThis.Map = __w_pdfjs_require__(144);
+  })();
+
+  (function checkSetEntries() {
+    if (globalThis.Set && globalThis.Set.prototype.entries) {
+      return;
+    }
+
+    globalThis.Set = __w_pdfjs_require__(151);
+  })();
+
+  (function checkWeakMap() {
+    if (globalThis.WeakMap) {
+      return;
+    }
+
+    globalThis.WeakMap = __w_pdfjs_require__(153);
+  })();
+
+  (function checkWeakSet() {
+    if (globalThis.WeakSet) {
+      return;
+    }
+
+    globalThis.WeakSet = __w_pdfjs_require__(159);
+  })();
+
+  (function checkStringCodePointAt() {
+    if (String.prototype.codePointAt) {
+      return;
+    }
+
+    __w_pdfjs_require__(161);
+  })();
+
+  (function checkStringFromCodePoint() {
+    if (String.fromCodePoint) {
+      return;
+    }
+
+    String.fromCodePoint = __w_pdfjs_require__(163);
+  })();
+
+  (function checkSymbol() {
+    if (globalThis.Symbol) {
+      return;
+    }
+
+    __w_pdfjs_require__(165);
+  })();
+
+  (function checkStringPadStart() {
+    if (String.prototype.padStart) {
+      return;
+    }
+
+    __w_pdfjs_require__(188);
+  })();
+
+  (function checkStringPadEnd() {
+    if (String.prototype.padEnd) {
+      return;
+    }
+
+    __w_pdfjs_require__(193);
+  })();
+
+  (function checkObjectValues() {
+    if (Object.values) {
+      return;
+    }
+
+    Object.values = __w_pdfjs_require__(195);
+  })();
+}
 
 /***/ }),
-/* 4 */
+/* 7 */
 /***/ (function(module, exports, __w_pdfjs_require__) {
 
 "use strict";
@@ -1717,11 +2980,9087 @@ Object.defineProperty(exports, "__esModule", {
   value: true
 });
 exports.isNodeJS = void 0;
-const isNodeJS = typeof process === "object" && process + "" === "[object process]" && !process.versions.nw && !process.versions.electron;
+
+function _typeof(obj) { "@babel/helpers - typeof"; 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); }
+
+var isNodeJS = (typeof process === "undefined" ? "undefined" : _typeof(process)) === "object" && process + "" === "[object process]" && !process.versions.nw && !process.versions.electron;
 exports.isNodeJS = isNodeJS;
 
 /***/ }),
-/* 5 */
+/* 8 */
+/***/ (function(module, exports, __w_pdfjs_require__) {
+
+__w_pdfjs_require__(9);
+module.exports = __w_pdfjs_require__(11);
+
+/***/ }),
+/* 9 */
+/***/ (function(module, exports, __w_pdfjs_require__) {
+
+var $ = __w_pdfjs_require__(10);
+var global = __w_pdfjs_require__(11);
+$({ global: true }, { globalThis: global });
+
+/***/ }),
+/* 10 */
+/***/ (function(module, exports, __w_pdfjs_require__) {
+
+var global = __w_pdfjs_require__(11);
+var getOwnPropertyDescriptor = __w_pdfjs_require__(12).f;
+var createNonEnumerableProperty = __w_pdfjs_require__(26);
+var redefine = __w_pdfjs_require__(29);
+var setGlobal = __w_pdfjs_require__(30);
+var copyConstructorProperties = __w_pdfjs_require__(40);
+var isForced = __w_pdfjs_require__(52);
+module.exports = function (options, source) {
+ var TARGET = options.target;
+ var GLOBAL = options.global;
+ var STATIC = options.stat;
+ var FORCED, target, key, targetProperty, sourceProperty, descriptor;
+ if (GLOBAL) {
+  target = global;
+ } else if (STATIC) {
+  target = global[TARGET] || setGlobal(TARGET, {});
+ } else {
+  target = (global[TARGET] || {}).prototype;
+ }
+ if (target)
+  for (key in source) {
+   sourceProperty = source[key];
+   if (options.noTargetGet) {
+    descriptor = getOwnPropertyDescriptor(target, key);
+    targetProperty = descriptor && descriptor.value;
+   } else
+    targetProperty = target[key];
+   FORCED = isForced(GLOBAL ? key : TARGET + (STATIC ? '.' : '#') + key, options.forced);
+   if (!FORCED && targetProperty !== undefined) {
+    if (typeof sourceProperty === typeof targetProperty)
+     continue;
+    copyConstructorProperties(sourceProperty, targetProperty);
+   }
+   if (options.sham || targetProperty && targetProperty.sham) {
+    createNonEnumerableProperty(sourceProperty, 'sham', true);
+   }
+   redefine(target, key, sourceProperty, options);
+  }
+};
+
+/***/ }),
+/* 11 */
+/***/ (function(module, exports) {
+
+var check = function (it) {
+ return it && it.Math == Math && it;
+};
+module.exports = check(typeof globalThis == 'object' && globalThis) || check(typeof window == 'object' && window) || check(typeof self == 'object' && self) || check(typeof global == 'object' && global) || Function('return this')();
+
+/***/ }),
+/* 12 */
+/***/ (function(module, exports, __w_pdfjs_require__) {
+
+var DESCRIPTORS = __w_pdfjs_require__(13);
+var propertyIsEnumerableModule = __w_pdfjs_require__(15);
+var createPropertyDescriptor = __w_pdfjs_require__(16);
+var toIndexedObject = __w_pdfjs_require__(17);
+var toPrimitive = __w_pdfjs_require__(21);
+var has = __w_pdfjs_require__(23);
+var IE8_DOM_DEFINE = __w_pdfjs_require__(24);
+var nativeGetOwnPropertyDescriptor = Object.getOwnPropertyDescriptor;
+exports.f = DESCRIPTORS ? nativeGetOwnPropertyDescriptor : function getOwnPropertyDescriptor(O, P) {
+ O = toIndexedObject(O);
+ P = toPrimitive(P, true);
+ if (IE8_DOM_DEFINE)
+  try {
+   return nativeGetOwnPropertyDescriptor(O, P);
+  } catch (error) {
+  }
+ if (has(O, P))
+  return createPropertyDescriptor(!propertyIsEnumerableModule.f.call(O, P), O[P]);
+};
+
+/***/ }),
+/* 13 */
+/***/ (function(module, exports, __w_pdfjs_require__) {
+
+var fails = __w_pdfjs_require__(14);
+module.exports = !fails(function () {
+ return Object.defineProperty({}, 1, {
+  get: function () {
+   return 7;
+  }
+ })[1] != 7;
+});
+
+/***/ }),
+/* 14 */
+/***/ (function(module, exports) {
+
+module.exports = function (exec) {
+ try {
+  return !!exec();
+ } catch (error) {
+  return true;
+ }
+};
+
+/***/ }),
+/* 15 */
+/***/ (function(module, exports, __w_pdfjs_require__) {
+
+"use strict";
+
+var nativePropertyIsEnumerable = {}.propertyIsEnumerable;
+var getOwnPropertyDescriptor = Object.getOwnPropertyDescriptor;
+var NASHORN_BUG = getOwnPropertyDescriptor && !nativePropertyIsEnumerable.call({ 1: 2 }, 1);
+exports.f = NASHORN_BUG ? function propertyIsEnumerable(V) {
+ var descriptor = getOwnPropertyDescriptor(this, V);
+ return !!descriptor && descriptor.enumerable;
+} : nativePropertyIsEnumerable;
+
+/***/ }),
+/* 16 */
+/***/ (function(module, exports) {
+
+module.exports = function (bitmap, value) {
+ return {
+  enumerable: !(bitmap & 1),
+  configurable: !(bitmap & 2),
+  writable: !(bitmap & 4),
+  value: value
+ };
+};
+
+/***/ }),
+/* 17 */
+/***/ (function(module, exports, __w_pdfjs_require__) {
+
+var IndexedObject = __w_pdfjs_require__(18);
+var requireObjectCoercible = __w_pdfjs_require__(20);
+module.exports = function (it) {
+ return IndexedObject(requireObjectCoercible(it));
+};
+
+/***/ }),
+/* 18 */
+/***/ (function(module, exports, __w_pdfjs_require__) {
+
+var fails = __w_pdfjs_require__(14);
+var classof = __w_pdfjs_require__(19);
+var split = ''.split;
+module.exports = fails(function () {
+ return !Object('z').propertyIsEnumerable(0);
+}) ? function (it) {
+ return classof(it) == 'String' ? split.call(it, '') : Object(it);
+} : Object;
+
+/***/ }),
+/* 19 */
+/***/ (function(module, exports) {
+
+var toString = {}.toString;
+module.exports = function (it) {
+ return toString.call(it).slice(8, -1);
+};
+
+/***/ }),
+/* 20 */
+/***/ (function(module, exports) {
+
+module.exports = function (it) {
+ if (it == undefined)
+  throw TypeError("Can't call method on " + it);
+ return it;
+};
+
+/***/ }),
+/* 21 */
+/***/ (function(module, exports, __w_pdfjs_require__) {
+
+var isObject = __w_pdfjs_require__(22);
+module.exports = function (input, PREFERRED_STRING) {
+ if (!isObject(input))
+  return input;
+ var fn, val;
+ if (PREFERRED_STRING && typeof (fn = input.toString) == 'function' && !isObject(val = fn.call(input)))
+  return val;
+ if (typeof (fn = input.valueOf) == 'function' && !isObject(val = fn.call(input)))
+  return val;
+ if (!PREFERRED_STRING && typeof (fn = input.toString) == 'function' && !isObject(val = fn.call(input)))
+  return val;
+ throw TypeError("Can't convert object to primitive value");
+};
+
+/***/ }),
+/* 22 */
+/***/ (function(module, exports) {
+
+module.exports = function (it) {
+ return typeof it === 'object' ? it !== null : typeof it === 'function';
+};
+
+/***/ }),
+/* 23 */
+/***/ (function(module, exports) {
+
+var hasOwnProperty = {}.hasOwnProperty;
+module.exports = function (it, key) {
+ return hasOwnProperty.call(it, key);
+};
+
+/***/ }),
+/* 24 */
+/***/ (function(module, exports, __w_pdfjs_require__) {
+
+var DESCRIPTORS = __w_pdfjs_require__(13);
+var fails = __w_pdfjs_require__(14);
+var createElement = __w_pdfjs_require__(25);
+module.exports = !DESCRIPTORS && !fails(function () {
+ return Object.defineProperty(createElement('div'), 'a', {
+  get: function () {
+   return 7;
+  }
+ }).a != 7;
+});
+
+/***/ }),
+/* 25 */
+/***/ (function(module, exports, __w_pdfjs_require__) {
+
+var global = __w_pdfjs_require__(11);
+var isObject = __w_pdfjs_require__(22);
+var document = global.document;
+var EXISTS = isObject(document) && isObject(document.createElement);
+module.exports = function (it) {
+ return EXISTS ? document.createElement(it) : {};
+};
+
+/***/ }),
+/* 26 */
+/***/ (function(module, exports, __w_pdfjs_require__) {
+
+var DESCRIPTORS = __w_pdfjs_require__(13);
+var definePropertyModule = __w_pdfjs_require__(27);
+var createPropertyDescriptor = __w_pdfjs_require__(16);
+module.exports = DESCRIPTORS ? function (object, key, value) {
+ return definePropertyModule.f(object, key, createPropertyDescriptor(1, value));
+} : function (object, key, value) {
+ object[key] = value;
+ return object;
+};
+
+/***/ }),
+/* 27 */
+/***/ (function(module, exports, __w_pdfjs_require__) {
+
+var DESCRIPTORS = __w_pdfjs_require__(13);
+var IE8_DOM_DEFINE = __w_pdfjs_require__(24);
+var anObject = __w_pdfjs_require__(28);
+var toPrimitive = __w_pdfjs_require__(21);
+var nativeDefineProperty = Object.defineProperty;
+exports.f = DESCRIPTORS ? nativeDefineProperty : function defineProperty(O, P, Attributes) {
+ anObject(O);
+ P = toPrimitive(P, true);
+ anObject(Attributes);
+ if (IE8_DOM_DEFINE)
+  try {
+   return nativeDefineProperty(O, P, Attributes);
+  } catch (error) {
+  }
+ if ('get' in Attributes || 'set' in Attributes)
+  throw TypeError('Accessors not supported');
+ if ('value' in Attributes)
+  O[P] = Attributes.value;
+ return O;
+};
+
+/***/ }),
+/* 28 */
+/***/ (function(module, exports, __w_pdfjs_require__) {
+
+var isObject = __w_pdfjs_require__(22);
+module.exports = function (it) {
+ if (!isObject(it)) {
+  throw TypeError(String(it) + ' is not an object');
+ }
+ return it;
+};
+
+/***/ }),
+/* 29 */
+/***/ (function(module, exports, __w_pdfjs_require__) {
+
+var global = __w_pdfjs_require__(11);
+var createNonEnumerableProperty = __w_pdfjs_require__(26);
+var has = __w_pdfjs_require__(23);
+var setGlobal = __w_pdfjs_require__(30);
+var inspectSource = __w_pdfjs_require__(31);
+var InternalStateModule = __w_pdfjs_require__(33);
+var getInternalState = InternalStateModule.get;
+var enforceInternalState = InternalStateModule.enforce;
+var TEMPLATE = String(String).split('String');
+(module.exports = function (O, key, value, options) {
+ var unsafe = options ? !!options.unsafe : false;
+ var simple = options ? !!options.enumerable : false;
+ var noTargetGet = options ? !!options.noTargetGet : false;
+ if (typeof value == 'function') {
+  if (typeof key == 'string' && !has(value, 'name'))
+   createNonEnumerableProperty(value, 'name', key);
+  enforceInternalState(value).source = TEMPLATE.join(typeof key == 'string' ? key : '');
+ }
+ if (O === global) {
+  if (simple)
+   O[key] = value;
+  else
+   setGlobal(key, value);
+  return;
+ } else if (!unsafe) {
+  delete O[key];
+ } else if (!noTargetGet && O[key]) {
+  simple = true;
+ }
+ if (simple)
+  O[key] = value;
+ else
+  createNonEnumerableProperty(O, key, value);
+})(Function.prototype, 'toString', function toString() {
+ return typeof this == 'function' && getInternalState(this).source || inspectSource(this);
+});
+
+/***/ }),
+/* 30 */
+/***/ (function(module, exports, __w_pdfjs_require__) {
+
+var global = __w_pdfjs_require__(11);
+var createNonEnumerableProperty = __w_pdfjs_require__(26);
+module.exports = function (key, value) {
+ try {
+  createNonEnumerableProperty(global, key, value);
+ } catch (error) {
+  global[key] = value;
+ }
+ return value;
+};
+
+/***/ }),
+/* 31 */
+/***/ (function(module, exports, __w_pdfjs_require__) {
+
+var store = __w_pdfjs_require__(32);
+var functionToString = Function.toString;
+if (typeof store.inspectSource != 'function') {
+ store.inspectSource = function (it) {
+  return functionToString.call(it);
+ };
+}
+module.exports = store.inspectSource;
+
+/***/ }),
+/* 32 */
+/***/ (function(module, exports, __w_pdfjs_require__) {
+
+var global = __w_pdfjs_require__(11);
+var setGlobal = __w_pdfjs_require__(30);
+var SHARED = '__core-js_shared__';
+var store = global[SHARED] || setGlobal(SHARED, {});
+module.exports = store;
+
+/***/ }),
+/* 33 */
+/***/ (function(module, exports, __w_pdfjs_require__) {
+
+var NATIVE_WEAK_MAP = __w_pdfjs_require__(34);
+var global = __w_pdfjs_require__(11);
+var isObject = __w_pdfjs_require__(22);
+var createNonEnumerableProperty = __w_pdfjs_require__(26);
+var objectHas = __w_pdfjs_require__(23);
+var sharedKey = __w_pdfjs_require__(35);
+var hiddenKeys = __w_pdfjs_require__(39);
+var WeakMap = global.WeakMap;
+var set, get, has;
+var enforce = function (it) {
+ return has(it) ? get(it) : set(it, {});
+};
+var getterFor = function (TYPE) {
+ return function (it) {
+  var state;
+  if (!isObject(it) || (state = get(it)).type !== TYPE) {
+   throw TypeError('Incompatible receiver, ' + TYPE + ' required');
+  }
+  return state;
+ };
+};
+if (NATIVE_WEAK_MAP) {
+ var store = new WeakMap();
+ var wmget = store.get;
+ var wmhas = store.has;
+ var wmset = store.set;
+ set = function (it, metadata) {
+  wmset.call(store, it, metadata);
+  return metadata;
+ };
+ get = function (it) {
+  return wmget.call(store, it) || {};
+ };
+ has = function (it) {
+  return wmhas.call(store, it);
+ };
+} else {
+ var STATE = sharedKey('state');
+ hiddenKeys[STATE] = true;
+ set = function (it, metadata) {
+  createNonEnumerableProperty(it, STATE, metadata);
+  return metadata;
+ };
+ get = function (it) {
+  return objectHas(it, STATE) ? it[STATE] : {};
+ };
+ has = function (it) {
+  return objectHas(it, STATE);
+ };
+}
+module.exports = {
+ set: set,
+ get: get,
+ has: has,
+ enforce: enforce,
+ getterFor: getterFor
+};
+
+/***/ }),
+/* 34 */
+/***/ (function(module, exports, __w_pdfjs_require__) {
+
+var global = __w_pdfjs_require__(11);
+var inspectSource = __w_pdfjs_require__(31);
+var WeakMap = global.WeakMap;
+module.exports = typeof WeakMap === 'function' && /native code/.test(inspectSource(WeakMap));
+
+/***/ }),
+/* 35 */
+/***/ (function(module, exports, __w_pdfjs_require__) {
+
+var shared = __w_pdfjs_require__(36);
+var uid = __w_pdfjs_require__(38);
+var keys = shared('keys');
+module.exports = function (key) {
+ return keys[key] || (keys[key] = uid(key));
+};
+
+/***/ }),
+/* 36 */
+/***/ (function(module, exports, __w_pdfjs_require__) {
+
+var IS_PURE = __w_pdfjs_require__(37);
+var store = __w_pdfjs_require__(32);
+(module.exports = function (key, value) {
+ return store[key] || (store[key] = value !== undefined ? value : {});
+})('versions', []).push({
+ version: '3.6.5',
+ mode: IS_PURE ? 'pure' : 'global',
+ copyright: '© 2020 Denis Pushkarev (zloirock.ru)'
+});
+
+/***/ }),
+/* 37 */
+/***/ (function(module, exports) {
+
+module.exports = false;
+
+/***/ }),
+/* 38 */
+/***/ (function(module, exports) {
+
+var id = 0;
+var postfix = Math.random();
+module.exports = function (key) {
+ return 'Symbol(' + String(key === undefined ? '' : key) + ')_' + (++id + postfix).toString(36);
+};
+
+/***/ }),
+/* 39 */
+/***/ (function(module, exports) {
+
+module.exports = {};
+
+/***/ }),
+/* 40 */
+/***/ (function(module, exports, __w_pdfjs_require__) {
+
+var has = __w_pdfjs_require__(23);
+var ownKeys = __w_pdfjs_require__(41);
+var getOwnPropertyDescriptorModule = __w_pdfjs_require__(12);
+var definePropertyModule = __w_pdfjs_require__(27);
+module.exports = function (target, source) {
+ var keys = ownKeys(source);
+ var defineProperty = definePropertyModule.f;
+ var getOwnPropertyDescriptor = getOwnPropertyDescriptorModule.f;
+ for (var i = 0; i < keys.length; i++) {
+  var key = keys[i];
+  if (!has(target, key))
+   defineProperty(target, key, getOwnPropertyDescriptor(source, key));
+ }
+};
+
+/***/ }),
+/* 41 */
+/***/ (function(module, exports, __w_pdfjs_require__) {
+
+var getBuiltIn = __w_pdfjs_require__(42);
+var getOwnPropertyNamesModule = __w_pdfjs_require__(44);
+var getOwnPropertySymbolsModule = __w_pdfjs_require__(51);
+var anObject = __w_pdfjs_require__(28);
+module.exports = getBuiltIn('Reflect', 'ownKeys') || function ownKeys(it) {
+ var keys = getOwnPropertyNamesModule.f(anObject(it));
+ var getOwnPropertySymbols = getOwnPropertySymbolsModule.f;
+ return getOwnPropertySymbols ? keys.concat(getOwnPropertySymbols(it)) : keys;
+};
+
+/***/ }),
+/* 42 */
+/***/ (function(module, exports, __w_pdfjs_require__) {
+
+var path = __w_pdfjs_require__(43);
+var global = __w_pdfjs_require__(11);
+var aFunction = function (variable) {
+ return typeof variable == 'function' ? variable : undefined;
+};
+module.exports = function (namespace, method) {
+ return arguments.length < 2 ? aFunction(path[namespace]) || aFunction(global[namespace]) : path[namespace] && path[namespace][method] || global[namespace] && global[namespace][method];
+};
+
+/***/ }),
+/* 43 */
+/***/ (function(module, exports, __w_pdfjs_require__) {
+
+var global = __w_pdfjs_require__(11);
+module.exports = global;
+
+/***/ }),
+/* 44 */
+/***/ (function(module, exports, __w_pdfjs_require__) {
+
+var internalObjectKeys = __w_pdfjs_require__(45);
+var enumBugKeys = __w_pdfjs_require__(50);
+var hiddenKeys = enumBugKeys.concat('length', 'prototype');
+exports.f = Object.getOwnPropertyNames || function getOwnPropertyNames(O) {
+ return internalObjectKeys(O, hiddenKeys);
+};
+
+/***/ }),
+/* 45 */
+/***/ (function(module, exports, __w_pdfjs_require__) {
+
+var has = __w_pdfjs_require__(23);
+var toIndexedObject = __w_pdfjs_require__(17);
+var indexOf = __w_pdfjs_require__(46).indexOf;
+var hiddenKeys = __w_pdfjs_require__(39);
+module.exports = function (object, names) {
+ var O = toIndexedObject(object);
+ var i = 0;
+ var result = [];
+ var key;
+ for (key in O)
+  !has(hiddenKeys, key) && has(O, key) && result.push(key);
+ while (names.length > i)
+  if (has(O, key = names[i++])) {
+   ~indexOf(result, key) || result.push(key);
+  }
+ return result;
+};
+
+/***/ }),
+/* 46 */
+/***/ (function(module, exports, __w_pdfjs_require__) {
+
+var toIndexedObject = __w_pdfjs_require__(17);
+var toLength = __w_pdfjs_require__(47);
+var toAbsoluteIndex = __w_pdfjs_require__(49);
+var createMethod = function (IS_INCLUDES) {
+ return function ($this, el, fromIndex) {
+  var O = toIndexedObject($this);
+  var length = toLength(O.length);
+  var index = toAbsoluteIndex(fromIndex, length);
+  var value;
+  if (IS_INCLUDES && el != el)
+   while (length > index) {
+    value = O[index++];
+    if (value != value)
+     return true;
+   }
+  else
+   for (; length > index; index++) {
+    if ((IS_INCLUDES || index in O) && O[index] === el)
+     return IS_INCLUDES || index || 0;
+   }
+  return !IS_INCLUDES && -1;
+ };
+};
+module.exports = {
+ includes: createMethod(true),
+ indexOf: createMethod(false)
+};
+
+/***/ }),
+/* 47 */
+/***/ (function(module, exports, __w_pdfjs_require__) {
+
+var toInteger = __w_pdfjs_require__(48);
+var min = Math.min;
+module.exports = function (argument) {
+ return argument > 0 ? min(toInteger(argument), 0x1FFFFFFFFFFFFF) : 0;
+};
+
+/***/ }),
+/* 48 */
+/***/ (function(module, exports) {
+
+var ceil = Math.ceil;
+var floor = Math.floor;
+module.exports = function (argument) {
+ return isNaN(argument = +argument) ? 0 : (argument > 0 ? floor : ceil)(argument);
+};
+
+/***/ }),
+/* 49 */
+/***/ (function(module, exports, __w_pdfjs_require__) {
+
+var toInteger = __w_pdfjs_require__(48);
+var max = Math.max;
+var min = Math.min;
+module.exports = function (index, length) {
+ var integer = toInteger(index);
+ return integer < 0 ? max(integer + length, 0) : min(integer, length);
+};
+
+/***/ }),
+/* 50 */
+/***/ (function(module, exports) {
+
+module.exports = [
+ 'constructor',
+ 'hasOwnProperty',
+ 'isPrototypeOf',
+ 'propertyIsEnumerable',
+ 'toLocaleString',
+ 'toString',
+ 'valueOf'
+];
+
+/***/ }),
+/* 51 */
+/***/ (function(module, exports) {
+
+exports.f = Object.getOwnPropertySymbols;
+
+/***/ }),
+/* 52 */
+/***/ (function(module, exports, __w_pdfjs_require__) {
+
+var fails = __w_pdfjs_require__(14);
+var replacement = /#|\.prototype\./;
+var isForced = function (feature, detection) {
+ var value = data[normalize(feature)];
+ return value == POLYFILL ? true : value == NATIVE ? false : typeof detection == 'function' ? fails(detection) : !!detection;
+};
+var normalize = isForced.normalize = function (string) {
+ return String(string).replace(replacement, '.').toLowerCase();
+};
+var data = isForced.data = {};
+var NATIVE = isForced.NATIVE = 'N';
+var POLYFILL = isForced.POLYFILL = 'P';
+module.exports = isForced;
+
+/***/ }),
+/* 53 */
+/***/ (function(module, exports, __w_pdfjs_require__) {
+
+__w_pdfjs_require__(54);
+var entryUnbind = __w_pdfjs_require__(61);
+module.exports = entryUnbind('String', 'startsWith');
+
+/***/ }),
+/* 54 */
+/***/ (function(module, exports, __w_pdfjs_require__) {
+
+"use strict";
+
+var $ = __w_pdfjs_require__(10);
+var getOwnPropertyDescriptor = __w_pdfjs_require__(12).f;
+var toLength = __w_pdfjs_require__(47);
+var notARegExp = __w_pdfjs_require__(55);
+var requireObjectCoercible = __w_pdfjs_require__(20);
+var correctIsRegExpLogic = __w_pdfjs_require__(60);
+var IS_PURE = __w_pdfjs_require__(37);
+var nativeStartsWith = ''.startsWith;
+var min = Math.min;
+var CORRECT_IS_REGEXP_LOGIC = correctIsRegExpLogic('startsWith');
+var MDN_POLYFILL_BUG = !IS_PURE && !CORRECT_IS_REGEXP_LOGIC && !!function () {
+ var descriptor = getOwnPropertyDescriptor(String.prototype, 'startsWith');
+ return descriptor && !descriptor.writable;
+}();
+$({
+ target: 'String',
+ proto: true,
+ forced: !MDN_POLYFILL_BUG && !CORRECT_IS_REGEXP_LOGIC
+}, {
+ startsWith: function startsWith(searchString) {
+  var that = String(requireObjectCoercible(this));
+  notARegExp(searchString);
+  var index = toLength(min(arguments.length > 1 ? arguments[1] : undefined, that.length));
+  var search = String(searchString);
+  return nativeStartsWith ? nativeStartsWith.call(that, search, index) : that.slice(index, index + search.length) === search;
+ }
+});
+
+/***/ }),
+/* 55 */
+/***/ (function(module, exports, __w_pdfjs_require__) {
+
+var isRegExp = __w_pdfjs_require__(56);
+module.exports = function (it) {
+ if (isRegExp(it)) {
+  throw TypeError("The method doesn't accept regular expressions");
+ }
+ return it;
+};
+
+/***/ }),
+/* 56 */
+/***/ (function(module, exports, __w_pdfjs_require__) {
+
+var isObject = __w_pdfjs_require__(22);
+var classof = __w_pdfjs_require__(19);
+var wellKnownSymbol = __w_pdfjs_require__(57);
+var MATCH = wellKnownSymbol('match');
+module.exports = function (it) {
+ var isRegExp;
+ return isObject(it) && ((isRegExp = it[MATCH]) !== undefined ? !!isRegExp : classof(it) == 'RegExp');
+};
+
+/***/ }),
+/* 57 */
+/***/ (function(module, exports, __w_pdfjs_require__) {
+
+var global = __w_pdfjs_require__(11);
+var shared = __w_pdfjs_require__(36);
+var has = __w_pdfjs_require__(23);
+var uid = __w_pdfjs_require__(38);
+var NATIVE_SYMBOL = __w_pdfjs_require__(58);
+var USE_SYMBOL_AS_UID = __w_pdfjs_require__(59);
+var WellKnownSymbolsStore = shared('wks');
+var Symbol = global.Symbol;
+var createWellKnownSymbol = USE_SYMBOL_AS_UID ? Symbol : Symbol && Symbol.withoutSetter || uid;
+module.exports = function (name) {
+ if (!has(WellKnownSymbolsStore, name)) {
+  if (NATIVE_SYMBOL && has(Symbol, name))
+   WellKnownSymbolsStore[name] = Symbol[name];
+  else
+   WellKnownSymbolsStore[name] = createWellKnownSymbol('Symbol.' + name);
+ }
+ return WellKnownSymbolsStore[name];
+};
+
+/***/ }),
+/* 58 */
+/***/ (function(module, exports, __w_pdfjs_require__) {
+
+var fails = __w_pdfjs_require__(14);
+module.exports = !!Object.getOwnPropertySymbols && !fails(function () {
+ return !String(Symbol());
+});
+
+/***/ }),
+/* 59 */
+/***/ (function(module, exports, __w_pdfjs_require__) {
+
+var NATIVE_SYMBOL = __w_pdfjs_require__(58);
+module.exports = NATIVE_SYMBOL && !Symbol.sham && typeof Symbol.iterator == 'symbol';
+
+/***/ }),
+/* 60 */
+/***/ (function(module, exports, __w_pdfjs_require__) {
+
+var wellKnownSymbol = __w_pdfjs_require__(57);
+var MATCH = wellKnownSymbol('match');
+module.exports = function (METHOD_NAME) {
+ var regexp = /./;
+ try {
+  '/./'[METHOD_NAME](regexp);
+ } catch (e) {
+  try {
+   regexp[MATCH] = false;
+   return '/./'[METHOD_NAME](regexp);
+  } catch (f) {
+  }
+ }
+ return false;
+};
+
+/***/ }),
+/* 61 */
+/***/ (function(module, exports, __w_pdfjs_require__) {
+
+var global = __w_pdfjs_require__(11);
+var bind = __w_pdfjs_require__(62);
+var call = Function.call;
+module.exports = function (CONSTRUCTOR, METHOD, length) {
+ return bind(call, global[CONSTRUCTOR].prototype[METHOD], length);
+};
+
+/***/ }),
+/* 62 */
+/***/ (function(module, exports, __w_pdfjs_require__) {
+
+var aFunction = __w_pdfjs_require__(63);
+module.exports = function (fn, that, length) {
+ aFunction(fn);
+ if (that === undefined)
+  return fn;
+ switch (length) {
+ case 0:
+  return function () {
+   return fn.call(that);
+  };
+ case 1:
+  return function (a) {
+   return fn.call(that, a);
+  };
+ case 2:
+  return function (a, b) {
+   return fn.call(that, a, b);
+  };
+ case 3:
+  return function (a, b, c) {
+   return fn.call(that, a, b, c);
+  };
+ }
+ return function () {
+  return fn.apply(that, arguments);
+ };
+};
+
+/***/ }),
+/* 63 */
+/***/ (function(module, exports) {
+
+module.exports = function (it) {
+ if (typeof it != 'function') {
+  throw TypeError(String(it) + ' is not a function');
+ }
+ return it;
+};
+
+/***/ }),
+/* 64 */
+/***/ (function(module, exports, __w_pdfjs_require__) {
+
+__w_pdfjs_require__(65);
+var entryUnbind = __w_pdfjs_require__(61);
+module.exports = entryUnbind('String', 'endsWith');
+
+/***/ }),
+/* 65 */
+/***/ (function(module, exports, __w_pdfjs_require__) {
+
+"use strict";
+
+var $ = __w_pdfjs_require__(10);
+var getOwnPropertyDescriptor = __w_pdfjs_require__(12).f;
+var toLength = __w_pdfjs_require__(47);
+var notARegExp = __w_pdfjs_require__(55);
+var requireObjectCoercible = __w_pdfjs_require__(20);
+var correctIsRegExpLogic = __w_pdfjs_require__(60);
+var IS_PURE = __w_pdfjs_require__(37);
+var nativeEndsWith = ''.endsWith;
+var min = Math.min;
+var CORRECT_IS_REGEXP_LOGIC = correctIsRegExpLogic('endsWith');
+var MDN_POLYFILL_BUG = !IS_PURE && !CORRECT_IS_REGEXP_LOGIC && !!function () {
+ var descriptor = getOwnPropertyDescriptor(String.prototype, 'endsWith');
+ return descriptor && !descriptor.writable;
+}();
+$({
+ target: 'String',
+ proto: true,
+ forced: !MDN_POLYFILL_BUG && !CORRECT_IS_REGEXP_LOGIC
+}, {
+ endsWith: function endsWith(searchString) {
+  var that = String(requireObjectCoercible(this));
+  notARegExp(searchString);
+  var endPosition = arguments.length > 1 ? arguments[1] : undefined;
+  var len = toLength(that.length);
+  var end = endPosition === undefined ? len : min(toLength(endPosition), len);
+  var search = String(searchString);
+  return nativeEndsWith ? nativeEndsWith.call(that, search, end) : that.slice(end - search.length, end) === search;
+ }
+});
+
+/***/ }),
+/* 66 */
+/***/ (function(module, exports, __w_pdfjs_require__) {
+
+__w_pdfjs_require__(67);
+var entryUnbind = __w_pdfjs_require__(61);
+module.exports = entryUnbind('String', 'includes');
+
+/***/ }),
+/* 67 */
+/***/ (function(module, exports, __w_pdfjs_require__) {
+
+"use strict";
+
+var $ = __w_pdfjs_require__(10);
+var notARegExp = __w_pdfjs_require__(55);
+var requireObjectCoercible = __w_pdfjs_require__(20);
+var correctIsRegExpLogic = __w_pdfjs_require__(60);
+$({
+ target: 'String',
+ proto: true,
+ forced: !correctIsRegExpLogic('includes')
+}, {
+ includes: function includes(searchString) {
+  return !!~String(requireObjectCoercible(this)).indexOf(notARegExp(searchString), arguments.length > 1 ? arguments[1] : undefined);
+ }
+});
+
+/***/ }),
+/* 68 */
+/***/ (function(module, exports, __w_pdfjs_require__) {
+
+__w_pdfjs_require__(69);
+var entryUnbind = __w_pdfjs_require__(61);
+module.exports = entryUnbind('Array', 'includes');
+
+/***/ }),
+/* 69 */
+/***/ (function(module, exports, __w_pdfjs_require__) {
+
+"use strict";
+
+var $ = __w_pdfjs_require__(10);
+var $includes = __w_pdfjs_require__(46).includes;
+var addToUnscopables = __w_pdfjs_require__(70);
+var arrayMethodUsesToLength = __w_pdfjs_require__(75);
+var USES_TO_LENGTH = arrayMethodUsesToLength('indexOf', {
+ ACCESSORS: true,
+ 1: 0
+});
+$({
+ target: 'Array',
+ proto: true,
+ forced: !USES_TO_LENGTH
+}, {
+ includes: function includes(el) {
+  return $includes(this, el, arguments.length > 1 ? arguments[1] : undefined);
+ }
+});
+addToUnscopables('includes');
+
+/***/ }),
+/* 70 */
+/***/ (function(module, exports, __w_pdfjs_require__) {
+
+var wellKnownSymbol = __w_pdfjs_require__(57);
+var create = __w_pdfjs_require__(71);
+var definePropertyModule = __w_pdfjs_require__(27);
+var UNSCOPABLES = wellKnownSymbol('unscopables');
+var ArrayPrototype = Array.prototype;
+if (ArrayPrototype[UNSCOPABLES] == undefined) {
+ definePropertyModule.f(ArrayPrototype, UNSCOPABLES, {
+  configurable: true,
+  value: create(null)
+ });
+}
+module.exports = function (key) {
+ ArrayPrototype[UNSCOPABLES][key] = true;
+};
+
+/***/ }),
+/* 71 */
+/***/ (function(module, exports, __w_pdfjs_require__) {
+
+var anObject = __w_pdfjs_require__(28);
+var defineProperties = __w_pdfjs_require__(72);
+var enumBugKeys = __w_pdfjs_require__(50);
+var hiddenKeys = __w_pdfjs_require__(39);
+var html = __w_pdfjs_require__(74);
+var documentCreateElement = __w_pdfjs_require__(25);
+var sharedKey = __w_pdfjs_require__(35);
+var GT = '>';
+var LT = '<';
+var PROTOTYPE = 'prototype';
+var SCRIPT = 'script';
+var IE_PROTO = sharedKey('IE_PROTO');
+var EmptyConstructor = function () {
+};
+var scriptTag = function (content) {
+ return LT + SCRIPT + GT + content + LT + '/' + SCRIPT + GT;
+};
+var NullProtoObjectViaActiveX = function (activeXDocument) {
+ activeXDocument.write(scriptTag(''));
+ activeXDocument.close();
+ var temp = activeXDocument.parentWindow.Object;
+ activeXDocument = null;
+ return temp;
+};
+var NullProtoObjectViaIFrame = function () {
+ var iframe = documentCreateElement('iframe');
+ var JS = 'java' + SCRIPT + ':';
+ var iframeDocument;
+ iframe.style.display = 'none';
+ html.appendChild(iframe);
+ iframe.src = String(JS);
+ iframeDocument = iframe.contentWindow.document;
+ iframeDocument.open();
+ iframeDocument.write(scriptTag('document.F=Object'));
+ iframeDocument.close();
+ return iframeDocument.F;
+};
+var activeXDocument;
+var NullProtoObject = function () {
+ try {
+  activeXDocument = document.domain && new ActiveXObject('htmlfile');
+ } catch (error) {
+ }
+ NullProtoObject = activeXDocument ? NullProtoObjectViaActiveX(activeXDocument) : NullProtoObjectViaIFrame();
+ var length = enumBugKeys.length;
+ while (length--)
+  delete NullProtoObject[PROTOTYPE][enumBugKeys[length]];
+ return NullProtoObject();
+};
+hiddenKeys[IE_PROTO] = true;
+module.exports = Object.create || function create(O, Properties) {
+ var result;
+ if (O !== null) {
+  EmptyConstructor[PROTOTYPE] = anObject(O);
+  result = new EmptyConstructor();
+  EmptyConstructor[PROTOTYPE] = null;
+  result[IE_PROTO] = O;
+ } else
+  result = NullProtoObject();
+ return Properties === undefined ? result : defineProperties(result, Properties);
+};
+
+/***/ }),
+/* 72 */
+/***/ (function(module, exports, __w_pdfjs_require__) {
+
+var DESCRIPTORS = __w_pdfjs_require__(13);
+var definePropertyModule = __w_pdfjs_require__(27);
+var anObject = __w_pdfjs_require__(28);
+var objectKeys = __w_pdfjs_require__(73);
+module.exports = DESCRIPTORS ? Object.defineProperties : function defineProperties(O, Properties) {
+ anObject(O);
+ var keys = objectKeys(Properties);
+ var length = keys.length;
+ var index = 0;
+ var key;
+ while (length > index)
+  definePropertyModule.f(O, key = keys[index++], Properties[key]);
+ return O;
+};
+
+/***/ }),
+/* 73 */
+/***/ (function(module, exports, __w_pdfjs_require__) {
+
+var internalObjectKeys = __w_pdfjs_require__(45);
+var enumBugKeys = __w_pdfjs_require__(50);
+module.exports = Object.keys || function keys(O) {
+ return internalObjectKeys(O, enumBugKeys);
+};
+
+/***/ }),
+/* 74 */
+/***/ (function(module, exports, __w_pdfjs_require__) {
+
+var getBuiltIn = __w_pdfjs_require__(42);
+module.exports = getBuiltIn('document', 'documentElement');
+
+/***/ }),
+/* 75 */
+/***/ (function(module, exports, __w_pdfjs_require__) {
+
+var DESCRIPTORS = __w_pdfjs_require__(13);
+var fails = __w_pdfjs_require__(14);
+var has = __w_pdfjs_require__(23);
+var defineProperty = Object.defineProperty;
+var cache = {};
+var thrower = function (it) {
+ throw it;
+};
+module.exports = function (METHOD_NAME, options) {
+ if (has(cache, METHOD_NAME))
+  return cache[METHOD_NAME];
+ if (!options)
+  options = {};
+ var method = [][METHOD_NAME];
+ var ACCESSORS = has(options, 'ACCESSORS') ? options.ACCESSORS : false;
+ var argument0 = has(options, 0) ? options[0] : thrower;
+ var argument1 = has(options, 1) ? options[1] : undefined;
+ return cache[METHOD_NAME] = !!method && !fails(function () {
+  if (ACCESSORS && !DESCRIPTORS)
+   return true;
+  var O = { length: -1 };
+  if (ACCESSORS)
+   defineProperty(O, 1, {
+    enumerable: true,
+    get: thrower
+   });
+  else
+   O[1] = 1;
+  method.call(O, argument0, argument1);
+ });
+};
+
+/***/ }),
+/* 76 */
+/***/ (function(module, exports, __w_pdfjs_require__) {
+
+__w_pdfjs_require__(77);
+__w_pdfjs_require__(89);
+var path = __w_pdfjs_require__(43);
+module.exports = path.Array.from;
+
+/***/ }),
+/* 77 */
+/***/ (function(module, exports, __w_pdfjs_require__) {
+
+"use strict";
+
+var charAt = __w_pdfjs_require__(78).charAt;
+var InternalStateModule = __w_pdfjs_require__(33);
+var defineIterator = __w_pdfjs_require__(79);
+var STRING_ITERATOR = 'String Iterator';
+var setInternalState = InternalStateModule.set;
+var getInternalState = InternalStateModule.getterFor(STRING_ITERATOR);
+defineIterator(String, 'String', function (iterated) {
+ setInternalState(this, {
+  type: STRING_ITERATOR,
+  string: String(iterated),
+  index: 0
+ });
+}, function next() {
+ var state = getInternalState(this);
+ var string = state.string;
+ var index = state.index;
+ var point;
+ if (index >= string.length)
+  return {
+   value: undefined,
+   done: true
+  };
+ point = charAt(string, index);
+ state.index += point.length;
+ return {
+  value: point,
+  done: false
+ };
+});
+
+/***/ }),
+/* 78 */
+/***/ (function(module, exports, __w_pdfjs_require__) {
+
+var toInteger = __w_pdfjs_require__(48);
+var requireObjectCoercible = __w_pdfjs_require__(20);
+var createMethod = function (CONVERT_TO_STRING) {
+ return function ($this, pos) {
+  var S = String(requireObjectCoercible($this));
+  var position = toInteger(pos);
+  var size = S.length;
+  var first, second;
+  if (position < 0 || position >= size)
+   return CONVERT_TO_STRING ? '' : undefined;
+  first = S.charCodeAt(position);
+  return first < 0xD800 || first > 0xDBFF || position + 1 === size || (second = S.charCodeAt(position + 1)) < 0xDC00 || second > 0xDFFF ? CONVERT_TO_STRING ? S.charAt(position) : first : CONVERT_TO_STRING ? S.slice(position, position + 2) : (first - 0xD800 << 10) + (second - 0xDC00) + 0x10000;
+ };
+};
+module.exports = {
+ codeAt: createMethod(false),
+ charAt: createMethod(true)
+};
+
+/***/ }),
+/* 79 */
+/***/ (function(module, exports, __w_pdfjs_require__) {
+
+"use strict";
+
+var $ = __w_pdfjs_require__(10);
+var createIteratorConstructor = __w_pdfjs_require__(80);
+var getPrototypeOf = __w_pdfjs_require__(82);
+var setPrototypeOf = __w_pdfjs_require__(87);
+var setToStringTag = __w_pdfjs_require__(85);
+var createNonEnumerableProperty = __w_pdfjs_require__(26);
+var redefine = __w_pdfjs_require__(29);
+var wellKnownSymbol = __w_pdfjs_require__(57);
+var IS_PURE = __w_pdfjs_require__(37);
+var Iterators = __w_pdfjs_require__(86);
+var IteratorsCore = __w_pdfjs_require__(81);
+var IteratorPrototype = IteratorsCore.IteratorPrototype;
+var BUGGY_SAFARI_ITERATORS = IteratorsCore.BUGGY_SAFARI_ITERATORS;
+var ITERATOR = wellKnownSymbol('iterator');
+var KEYS = 'keys';
+var VALUES = 'values';
+var ENTRIES = 'entries';
+var returnThis = function () {
+ return this;
+};
+module.exports = function (Iterable, NAME, IteratorConstructor, next, DEFAULT, IS_SET, FORCED) {
+ createIteratorConstructor(IteratorConstructor, NAME, next);
+ var getIterationMethod = function (KIND) {
+  if (KIND === DEFAULT && defaultIterator)
+   return defaultIterator;
+  if (!BUGGY_SAFARI_ITERATORS && KIND in IterablePrototype)
+   return IterablePrototype[KIND];
+  switch (KIND) {
+  case KEYS:
+   return function keys() {
+    return new IteratorConstructor(this, KIND);
+   };
+  case VALUES:
+   return function values() {
+    return new IteratorConstructor(this, KIND);
+   };
+  case ENTRIES:
+   return function entries() {
+    return new IteratorConstructor(this, KIND);
+   };
+  }
+  return function () {
+   return new IteratorConstructor(this);
+  };
+ };
+ var TO_STRING_TAG = NAME + ' Iterator';
+ var INCORRECT_VALUES_NAME = false;
+ var IterablePrototype = Iterable.prototype;
+ var nativeIterator = IterablePrototype[ITERATOR] || IterablePrototype['@@iterator'] || DEFAULT && IterablePrototype[DEFAULT];
+ var defaultIterator = !BUGGY_SAFARI_ITERATORS && nativeIterator || getIterationMethod(DEFAULT);
+ var anyNativeIterator = NAME == 'Array' ? IterablePrototype.entries || nativeIterator : nativeIterator;
+ var CurrentIteratorPrototype, methods, KEY;
+ if (anyNativeIterator) {
+  CurrentIteratorPrototype = getPrototypeOf(anyNativeIterator.call(new Iterable()));
+  if (IteratorPrototype !== Object.prototype && CurrentIteratorPrototype.next) {
+   if (!IS_PURE && getPrototypeOf(CurrentIteratorPrototype) !== IteratorPrototype) {
+    if (setPrototypeOf) {
+     setPrototypeOf(CurrentIteratorPrototype, IteratorPrototype);
+    } else if (typeof CurrentIteratorPrototype[ITERATOR] != 'function') {
+     createNonEnumerableProperty(CurrentIteratorPrototype, ITERATOR, returnThis);
+    }
+   }
+   setToStringTag(CurrentIteratorPrototype, TO_STRING_TAG, true, true);
+   if (IS_PURE)
+    Iterators[TO_STRING_TAG] = returnThis;
+  }
+ }
+ if (DEFAULT == VALUES && nativeIterator && nativeIterator.name !== VALUES) {
+  INCORRECT_VALUES_NAME = true;
+  defaultIterator = function values() {
+   return nativeIterator.call(this);
+  };
+ }
+ if ((!IS_PURE || FORCED) && IterablePrototype[ITERATOR] !== defaultIterator) {
+  createNonEnumerableProperty(IterablePrototype, ITERATOR, defaultIterator);
+ }
+ Iterators[NAME] = defaultIterator;
+ if (DEFAULT) {
+  methods = {
+   values: getIterationMethod(VALUES),
+   keys: IS_SET ? defaultIterator : getIterationMethod(KEYS),
+   entries: getIterationMethod(ENTRIES)
+  };
+  if (FORCED)
+   for (KEY in methods) {
+    if (BUGGY_SAFARI_ITERATORS || INCORRECT_VALUES_NAME || !(KEY in IterablePrototype)) {
+     redefine(IterablePrototype, KEY, methods[KEY]);
+    }
+   }
+  else
+   $({
+    target: NAME,
+    proto: true,
+    forced: BUGGY_SAFARI_ITERATORS || INCORRECT_VALUES_NAME
+   }, methods);
+ }
+ return methods;
+};
+
+/***/ }),
+/* 80 */
+/***/ (function(module, exports, __w_pdfjs_require__) {
+
+"use strict";
+
+var IteratorPrototype = __w_pdfjs_require__(81).IteratorPrototype;
+var create = __w_pdfjs_require__(71);
+var createPropertyDescriptor = __w_pdfjs_require__(16);
+var setToStringTag = __w_pdfjs_require__(85);
+var Iterators = __w_pdfjs_require__(86);
+var returnThis = function () {
+ return this;
+};
+module.exports = function (IteratorConstructor, NAME, next) {
+ var TO_STRING_TAG = NAME + ' Iterator';
+ IteratorConstructor.prototype = create(IteratorPrototype, { next: createPropertyDescriptor(1, next) });
+ setToStringTag(IteratorConstructor, TO_STRING_TAG, false, true);
+ Iterators[TO_STRING_TAG] = returnThis;
+ return IteratorConstructor;
+};
+
+/***/ }),
+/* 81 */
+/***/ (function(module, exports, __w_pdfjs_require__) {
+
+"use strict";
+
+var getPrototypeOf = __w_pdfjs_require__(82);
+var createNonEnumerableProperty = __w_pdfjs_require__(26);
+var has = __w_pdfjs_require__(23);
+var wellKnownSymbol = __w_pdfjs_require__(57);
+var IS_PURE = __w_pdfjs_require__(37);
+var ITERATOR = wellKnownSymbol('iterator');
+var BUGGY_SAFARI_ITERATORS = false;
+var returnThis = function () {
+ return this;
+};
+var IteratorPrototype, PrototypeOfArrayIteratorPrototype, arrayIterator;
+if ([].keys) {
+ arrayIterator = [].keys();
+ if (!('next' in arrayIterator))
+  BUGGY_SAFARI_ITERATORS = true;
+ else {
+  PrototypeOfArrayIteratorPrototype = getPrototypeOf(getPrototypeOf(arrayIterator));
+  if (PrototypeOfArrayIteratorPrototype !== Object.prototype)
+   IteratorPrototype = PrototypeOfArrayIteratorPrototype;
+ }
+}
+if (IteratorPrototype == undefined)
+ IteratorPrototype = {};
+if (!IS_PURE && !has(IteratorPrototype, ITERATOR)) {
+ createNonEnumerableProperty(IteratorPrototype, ITERATOR, returnThis);
+}
+module.exports = {
+ IteratorPrototype: IteratorPrototype,
+ BUGGY_SAFARI_ITERATORS: BUGGY_SAFARI_ITERATORS
+};
+
+/***/ }),
+/* 82 */
+/***/ (function(module, exports, __w_pdfjs_require__) {
+
+var has = __w_pdfjs_require__(23);
+var toObject = __w_pdfjs_require__(83);
+var sharedKey = __w_pdfjs_require__(35);
+var CORRECT_PROTOTYPE_GETTER = __w_pdfjs_require__(84);
+var IE_PROTO = sharedKey('IE_PROTO');
+var ObjectPrototype = Object.prototype;
+module.exports = CORRECT_PROTOTYPE_GETTER ? Object.getPrototypeOf : function (O) {
+ O = toObject(O);
+ if (has(O, IE_PROTO))
+  return O[IE_PROTO];
+ if (typeof O.constructor == 'function' && O instanceof O.constructor) {
+  return O.constructor.prototype;
+ }
+ return O instanceof Object ? ObjectPrototype : null;
+};
+
+/***/ }),
+/* 83 */
+/***/ (function(module, exports, __w_pdfjs_require__) {
+
+var requireObjectCoercible = __w_pdfjs_require__(20);
+module.exports = function (argument) {
+ return Object(requireObjectCoercible(argument));
+};
+
+/***/ }),
+/* 84 */
+/***/ (function(module, exports, __w_pdfjs_require__) {
+
+var fails = __w_pdfjs_require__(14);
+module.exports = !fails(function () {
+ function F() {
+ }
+ F.prototype.constructor = null;
+ return Object.getPrototypeOf(new F()) !== F.prototype;
+});
+
+/***/ }),
+/* 85 */
+/***/ (function(module, exports, __w_pdfjs_require__) {
+
+var defineProperty = __w_pdfjs_require__(27).f;
+var has = __w_pdfjs_require__(23);
+var wellKnownSymbol = __w_pdfjs_require__(57);
+var TO_STRING_TAG = wellKnownSymbol('toStringTag');
+module.exports = function (it, TAG, STATIC) {
+ if (it && !has(it = STATIC ? it : it.prototype, TO_STRING_TAG)) {
+  defineProperty(it, TO_STRING_TAG, {
+   configurable: true,
+   value: TAG
+  });
+ }
+};
+
+/***/ }),
+/* 86 */
+/***/ (function(module, exports) {
+
+module.exports = {};
+
+/***/ }),
+/* 87 */
+/***/ (function(module, exports, __w_pdfjs_require__) {
+
+var anObject = __w_pdfjs_require__(28);
+var aPossiblePrototype = __w_pdfjs_require__(88);
+module.exports = Object.setPrototypeOf || ('__proto__' in {} ? function () {
+ var CORRECT_SETTER = false;
+ var test = {};
+ var setter;
+ try {
+  setter = Object.getOwnPropertyDescriptor(Object.prototype, '__proto__').set;
+  setter.call(test, []);
+  CORRECT_SETTER = test instanceof Array;
+ } catch (error) {
+ }
+ return function setPrototypeOf(O, proto) {
+  anObject(O);
+  aPossiblePrototype(proto);
+  if (CORRECT_SETTER)
+   setter.call(O, proto);
+  else
+   O.__proto__ = proto;
+  return O;
+ };
+}() : undefined);
+
+/***/ }),
+/* 88 */
+/***/ (function(module, exports, __w_pdfjs_require__) {
+
+var isObject = __w_pdfjs_require__(22);
+module.exports = function (it) {
+ if (!isObject(it) && it !== null) {
+  throw TypeError("Can't set " + String(it) + ' as a prototype');
+ }
+ return it;
+};
+
+/***/ }),
+/* 89 */
+/***/ (function(module, exports, __w_pdfjs_require__) {
+
+var $ = __w_pdfjs_require__(10);
+var from = __w_pdfjs_require__(90);
+var checkCorrectnessOfIteration = __w_pdfjs_require__(97);
+var INCORRECT_ITERATION = !checkCorrectnessOfIteration(function (iterable) {
+ Array.from(iterable);
+});
+$({
+ target: 'Array',
+ stat: true,
+ forced: INCORRECT_ITERATION
+}, { from: from });
+
+/***/ }),
+/* 90 */
+/***/ (function(module, exports, __w_pdfjs_require__) {
+
+"use strict";
+
+var bind = __w_pdfjs_require__(62);
+var toObject = __w_pdfjs_require__(83);
+var callWithSafeIterationClosing = __w_pdfjs_require__(91);
+var isArrayIteratorMethod = __w_pdfjs_require__(92);
+var toLength = __w_pdfjs_require__(47);
+var createProperty = __w_pdfjs_require__(93);
+var getIteratorMethod = __w_pdfjs_require__(94);
+module.exports = function from(arrayLike) {
+ var O = toObject(arrayLike);
+ var C = typeof this == 'function' ? this : Array;
+ var argumentsLength = arguments.length;
+ var mapfn = argumentsLength > 1 ? arguments[1] : undefined;
+ var mapping = mapfn !== undefined;
+ var iteratorMethod = getIteratorMethod(O);
+ var index = 0;
+ var length, result, step, iterator, next, value;
+ if (mapping)
+  mapfn = bind(mapfn, argumentsLength > 2 ? arguments[2] : undefined, 2);
+ if (iteratorMethod != undefined && !(C == Array && isArrayIteratorMethod(iteratorMethod))) {
+  iterator = iteratorMethod.call(O);
+  next = iterator.next;
+  result = new C();
+  for (; !(step = next.call(iterator)).done; index++) {
+   value = mapping ? callWithSafeIterationClosing(iterator, mapfn, [
+    step.value,
+    index
+   ], true) : step.value;
+   createProperty(result, index, value);
+  }
+ } else {
+  length = toLength(O.length);
+  result = new C(length);
+  for (; length > index; index++) {
+   value = mapping ? mapfn(O[index], index) : O[index];
+   createProperty(result, index, value);
+  }
+ }
+ result.length = index;
+ return result;
+};
+
+/***/ }),
+/* 91 */
+/***/ (function(module, exports, __w_pdfjs_require__) {
+
+var anObject = __w_pdfjs_require__(28);
+module.exports = function (iterator, fn, value, ENTRIES) {
+ try {
+  return ENTRIES ? fn(anObject(value)[0], value[1]) : fn(value);
+ } catch (error) {
+  var returnMethod = iterator['return'];
+  if (returnMethod !== undefined)
+   anObject(returnMethod.call(iterator));
+  throw error;
+ }
+};
+
+/***/ }),
+/* 92 */
+/***/ (function(module, exports, __w_pdfjs_require__) {
+
+var wellKnownSymbol = __w_pdfjs_require__(57);
+var Iterators = __w_pdfjs_require__(86);
+var ITERATOR = wellKnownSymbol('iterator');
+var ArrayPrototype = Array.prototype;
+module.exports = function (it) {
+ return it !== undefined && (Iterators.Array === it || ArrayPrototype[ITERATOR] === it);
+};
+
+/***/ }),
+/* 93 */
+/***/ (function(module, exports, __w_pdfjs_require__) {
+
+"use strict";
+
+var toPrimitive = __w_pdfjs_require__(21);
+var definePropertyModule = __w_pdfjs_require__(27);
+var createPropertyDescriptor = __w_pdfjs_require__(16);
+module.exports = function (object, key, value) {
+ var propertyKey = toPrimitive(key);
+ if (propertyKey in object)
+  definePropertyModule.f(object, propertyKey, createPropertyDescriptor(0, value));
+ else
+  object[propertyKey] = value;
+};
+
+/***/ }),
+/* 94 */
+/***/ (function(module, exports, __w_pdfjs_require__) {
+
+var classof = __w_pdfjs_require__(95);
+var Iterators = __w_pdfjs_require__(86);
+var wellKnownSymbol = __w_pdfjs_require__(57);
+var ITERATOR = wellKnownSymbol('iterator');
+module.exports = function (it) {
+ if (it != undefined)
+  return it[ITERATOR] || it['@@iterator'] || Iterators[classof(it)];
+};
+
+/***/ }),
+/* 95 */
+/***/ (function(module, exports, __w_pdfjs_require__) {
+
+var TO_STRING_TAG_SUPPORT = __w_pdfjs_require__(96);
+var classofRaw = __w_pdfjs_require__(19);
+var wellKnownSymbol = __w_pdfjs_require__(57);
+var TO_STRING_TAG = wellKnownSymbol('toStringTag');
+var CORRECT_ARGUMENTS = classofRaw(function () {
+ return arguments;
+}()) == 'Arguments';
+var tryGet = function (it, key) {
+ try {
+  return it[key];
+ } catch (error) {
+ }
+};
+module.exports = TO_STRING_TAG_SUPPORT ? classofRaw : function (it) {
+ var O, tag, result;
+ return it === undefined ? 'Undefined' : it === null ? 'Null' : typeof (tag = tryGet(O = Object(it), TO_STRING_TAG)) == 'string' ? tag : CORRECT_ARGUMENTS ? classofRaw(O) : (result = classofRaw(O)) == 'Object' && typeof O.callee == 'function' ? 'Arguments' : result;
+};
+
+/***/ }),
+/* 96 */
+/***/ (function(module, exports, __w_pdfjs_require__) {
+
+var wellKnownSymbol = __w_pdfjs_require__(57);
+var TO_STRING_TAG = wellKnownSymbol('toStringTag');
+var test = {};
+test[TO_STRING_TAG] = 'z';
+module.exports = String(test) === '[object z]';
+
+/***/ }),
+/* 97 */
+/***/ (function(module, exports, __w_pdfjs_require__) {
+
+var wellKnownSymbol = __w_pdfjs_require__(57);
+var ITERATOR = wellKnownSymbol('iterator');
+var SAFE_CLOSING = false;
+try {
+ var called = 0;
+ var iteratorWithReturn = {
+  next: function () {
+   return { done: !!called++ };
+  },
+  'return': function () {
+   SAFE_CLOSING = true;
+  }
+ };
+ iteratorWithReturn[ITERATOR] = function () {
+  return this;
+ };
+ Array.from(iteratorWithReturn, function () {
+  throw 2;
+ });
+} catch (error) {
+}
+module.exports = function (exec, SKIP_CLOSING) {
+ if (!SKIP_CLOSING && !SAFE_CLOSING)
+  return false;
+ var ITERATION_SUPPORT = false;
+ try {
+  var object = {};
+  object[ITERATOR] = function () {
+   return {
+    next: function () {
+     return { done: ITERATION_SUPPORT = true };
+    }
+   };
+  };
+  exec(object);
+ } catch (error) {
+ }
+ return ITERATION_SUPPORT;
+};
+
+/***/ }),
+/* 98 */
+/***/ (function(module, exports, __w_pdfjs_require__) {
+
+__w_pdfjs_require__(99);
+var path = __w_pdfjs_require__(43);
+module.exports = path.Object.assign;
+
+/***/ }),
+/* 99 */
+/***/ (function(module, exports, __w_pdfjs_require__) {
+
+var $ = __w_pdfjs_require__(10);
+var assign = __w_pdfjs_require__(100);
+$({
+ target: 'Object',
+ stat: true,
+ forced: Object.assign !== assign
+}, { assign: assign });
+
+/***/ }),
+/* 100 */
+/***/ (function(module, exports, __w_pdfjs_require__) {
+
+"use strict";
+
+var DESCRIPTORS = __w_pdfjs_require__(13);
+var fails = __w_pdfjs_require__(14);
+var objectKeys = __w_pdfjs_require__(73);
+var getOwnPropertySymbolsModule = __w_pdfjs_require__(51);
+var propertyIsEnumerableModule = __w_pdfjs_require__(15);
+var toObject = __w_pdfjs_require__(83);
+var IndexedObject = __w_pdfjs_require__(18);
+var nativeAssign = Object.assign;
+var defineProperty = Object.defineProperty;
+module.exports = !nativeAssign || fails(function () {
+ if (DESCRIPTORS && nativeAssign({ b: 1 }, nativeAssign(defineProperty({}, 'a', {
+   enumerable: true,
+   get: function () {
+    defineProperty(this, 'b', {
+     value: 3,
+     enumerable: false
+    });
+   }
+  }), { b: 2 })).b !== 1)
+  return true;
+ var A = {};
+ var B = {};
+ var symbol = Symbol();
+ var alphabet = 'abcdefghijklmnopqrst';
+ A[symbol] = 7;
+ alphabet.split('').forEach(function (chr) {
+  B[chr] = chr;
+ });
+ return nativeAssign({}, A)[symbol] != 7 || objectKeys(nativeAssign({}, B)).join('') != alphabet;
+}) ? function assign(target, source) {
+ var T = toObject(target);
+ var argumentsLength = arguments.length;
+ var index = 1;
+ var getOwnPropertySymbols = getOwnPropertySymbolsModule.f;
+ var propertyIsEnumerable = propertyIsEnumerableModule.f;
+ while (argumentsLength > index) {
+  var S = IndexedObject(arguments[index++]);
+  var keys = getOwnPropertySymbols ? objectKeys(S).concat(getOwnPropertySymbols(S)) : objectKeys(S);
+  var length = keys.length;
+  var j = 0;
+  var key;
+  while (length > j) {
+   key = keys[j++];
+   if (!DESCRIPTORS || propertyIsEnumerable.call(S, key))
+    T[key] = S[key];
+  }
+ }
+ return T;
+} : nativeAssign;
+
+/***/ }),
+/* 101 */
+/***/ (function(module, exports, __w_pdfjs_require__) {
+
+__w_pdfjs_require__(102);
+var path = __w_pdfjs_require__(43);
+module.exports = path.Math.log2;
+
+/***/ }),
+/* 102 */
+/***/ (function(module, exports, __w_pdfjs_require__) {
+
+var $ = __w_pdfjs_require__(10);
+var log = Math.log;
+var LN2 = Math.LN2;
+$({
+ target: 'Math',
+ stat: true
+}, {
+ log2: function log2(x) {
+  return log(x) / LN2;
+ }
+});
+
+/***/ }),
+/* 103 */
+/***/ (function(module, exports, __w_pdfjs_require__) {
+
+__w_pdfjs_require__(104);
+var path = __w_pdfjs_require__(43);
+module.exports = path.Number.isNaN;
+
+/***/ }),
+/* 104 */
+/***/ (function(module, exports, __w_pdfjs_require__) {
+
+var $ = __w_pdfjs_require__(10);
+$({
+ target: 'Number',
+ stat: true
+}, {
+ isNaN: function isNaN(number) {
+  return number != number;
+ }
+});
+
+/***/ }),
+/* 105 */
+/***/ (function(module, exports, __w_pdfjs_require__) {
+
+__w_pdfjs_require__(106);
+var path = __w_pdfjs_require__(43);
+module.exports = path.Number.isInteger;
+
+/***/ }),
+/* 106 */
+/***/ (function(module, exports, __w_pdfjs_require__) {
+
+var $ = __w_pdfjs_require__(10);
+var isInteger = __w_pdfjs_require__(107);
+$({
+ target: 'Number',
+ stat: true
+}, { isInteger: isInteger });
+
+/***/ }),
+/* 107 */
+/***/ (function(module, exports, __w_pdfjs_require__) {
+
+var isObject = __w_pdfjs_require__(22);
+var floor = Math.floor;
+module.exports = function isInteger(it) {
+ return !isObject(it) && isFinite(it) && floor(it) === it;
+};
+
+/***/ }),
+/* 108 */
+/***/ (function(module, exports, __w_pdfjs_require__) {
+
+__w_pdfjs_require__(109);
+
+/***/ }),
+/* 109 */
+/***/ (function(module, exports, __w_pdfjs_require__) {
+
+"use strict";
+
+var ArrayBufferViewCore = __w_pdfjs_require__(110);
+var speciesConstructor = __w_pdfjs_require__(112);
+var fails = __w_pdfjs_require__(14);
+var aTypedArray = ArrayBufferViewCore.aTypedArray;
+var aTypedArrayConstructor = ArrayBufferViewCore.aTypedArrayConstructor;
+var exportTypedArrayMethod = ArrayBufferViewCore.exportTypedArrayMethod;
+var $slice = [].slice;
+var FORCED = fails(function () {
+ new Int8Array(1).slice();
+});
+exportTypedArrayMethod('slice', function slice(start, end) {
+ var list = $slice.call(aTypedArray(this), start, end);
+ var C = speciesConstructor(this, this.constructor);
+ var index = 0;
+ var length = list.length;
+ var result = new (aTypedArrayConstructor(C))(length);
+ while (length > index)
+  result[index] = list[index++];
+ return result;
+}, FORCED);
+
+/***/ }),
+/* 110 */
+/***/ (function(module, exports, __w_pdfjs_require__) {
+
+"use strict";
+
+var NATIVE_ARRAY_BUFFER = __w_pdfjs_require__(111);
+var DESCRIPTORS = __w_pdfjs_require__(13);
+var global = __w_pdfjs_require__(11);
+var isObject = __w_pdfjs_require__(22);
+var has = __w_pdfjs_require__(23);
+var classof = __w_pdfjs_require__(95);
+var createNonEnumerableProperty = __w_pdfjs_require__(26);
+var redefine = __w_pdfjs_require__(29);
+var defineProperty = __w_pdfjs_require__(27).f;
+var getPrototypeOf = __w_pdfjs_require__(82);
+var setPrototypeOf = __w_pdfjs_require__(87);
+var wellKnownSymbol = __w_pdfjs_require__(57);
+var uid = __w_pdfjs_require__(38);
+var Int8Array = global.Int8Array;
+var Int8ArrayPrototype = Int8Array && Int8Array.prototype;
+var Uint8ClampedArray = global.Uint8ClampedArray;
+var Uint8ClampedArrayPrototype = Uint8ClampedArray && Uint8ClampedArray.prototype;
+var TypedArray = Int8Array && getPrototypeOf(Int8Array);
+var TypedArrayPrototype = Int8ArrayPrototype && getPrototypeOf(Int8ArrayPrototype);
+var ObjectPrototype = Object.prototype;
+var isPrototypeOf = ObjectPrototype.isPrototypeOf;
+var TO_STRING_TAG = wellKnownSymbol('toStringTag');
+var TYPED_ARRAY_TAG = uid('TYPED_ARRAY_TAG');
+var NATIVE_ARRAY_BUFFER_VIEWS = NATIVE_ARRAY_BUFFER && !!setPrototypeOf && classof(global.opera) !== 'Opera';
+var TYPED_ARRAY_TAG_REQIRED = false;
+var NAME;
+var TypedArrayConstructorsList = {
+ Int8Array: 1,
+ Uint8Array: 1,
+ Uint8ClampedArray: 1,
+ Int16Array: 2,
+ Uint16Array: 2,
+ Int32Array: 4,
+ Uint32Array: 4,
+ Float32Array: 4,
+ Float64Array: 8
+};
+var isView = function isView(it) {
+ var klass = classof(it);
+ return klass === 'DataView' || has(TypedArrayConstructorsList, klass);
+};
+var isTypedArray = function (it) {
+ return isObject(it) && has(TypedArrayConstructorsList, classof(it));
+};
+var aTypedArray = function (it) {
+ if (isTypedArray(it))
+  return it;
+ throw TypeError('Target is not a typed array');
+};
+var aTypedArrayConstructor = function (C) {
+ if (setPrototypeOf) {
+  if (isPrototypeOf.call(TypedArray, C))
+   return C;
+ } else
+  for (var ARRAY in TypedArrayConstructorsList)
+   if (has(TypedArrayConstructorsList, NAME)) {
+    var TypedArrayConstructor = global[ARRAY];
+    if (TypedArrayConstructor && (C === TypedArrayConstructor || isPrototypeOf.call(TypedArrayConstructor, C))) {
+     return C;
+    }
+   }
+ throw TypeError('Target is not a typed array constructor');
+};
+var exportTypedArrayMethod = function (KEY, property, forced) {
+ if (!DESCRIPTORS)
+  return;
+ if (forced)
+  for (var ARRAY in TypedArrayConstructorsList) {
+   var TypedArrayConstructor = global[ARRAY];
+   if (TypedArrayConstructor && has(TypedArrayConstructor.prototype, KEY)) {
+    delete TypedArrayConstructor.prototype[KEY];
+   }
+  }
+ if (!TypedArrayPrototype[KEY] || forced) {
+  redefine(TypedArrayPrototype, KEY, forced ? property : NATIVE_ARRAY_BUFFER_VIEWS && Int8ArrayPrototype[KEY] || property);
+ }
+};
+var exportTypedArrayStaticMethod = function (KEY, property, forced) {
+ var ARRAY, TypedArrayConstructor;
+ if (!DESCRIPTORS)
+  return;
+ if (setPrototypeOf) {
+  if (forced)
+   for (ARRAY in TypedArrayConstructorsList) {
+    TypedArrayConstructor = global[ARRAY];
+    if (TypedArrayConstructor && has(TypedArrayConstructor, KEY)) {
+     delete TypedArrayConstructor[KEY];
+    }
+   }
+  if (!TypedArray[KEY] || forced) {
+   try {
+    return redefine(TypedArray, KEY, forced ? property : NATIVE_ARRAY_BUFFER_VIEWS && Int8Array[KEY] || property);
+   } catch (error) {
+   }
+  } else
+   return;
+ }
+ for (ARRAY in TypedArrayConstructorsList) {
+  TypedArrayConstructor = global[ARRAY];
+  if (TypedArrayConstructor && (!TypedArrayConstructor[KEY] || forced)) {
+   redefine(TypedArrayConstructor, KEY, property);
+  }
+ }
+};
+for (NAME in TypedArrayConstructorsList) {
+ if (!global[NAME])
+  NATIVE_ARRAY_BUFFER_VIEWS = false;
+}
+if (!NATIVE_ARRAY_BUFFER_VIEWS || typeof TypedArray != 'function' || TypedArray === Function.prototype) {
+ TypedArray = function TypedArray() {
+  throw TypeError('Incorrect invocation');
+ };
+ if (NATIVE_ARRAY_BUFFER_VIEWS)
+  for (NAME in TypedArrayConstructorsList) {
+   if (global[NAME])
+    setPrototypeOf(global[NAME], TypedArray);
+  }
+}
+if (!NATIVE_ARRAY_BUFFER_VIEWS || !TypedArrayPrototype || TypedArrayPrototype === ObjectPrototype) {
+ TypedArrayPrototype = TypedArray.prototype;
+ if (NATIVE_ARRAY_BUFFER_VIEWS)
+  for (NAME in TypedArrayConstructorsList) {
+   if (global[NAME])
+    setPrototypeOf(global[NAME].prototype, TypedArrayPrototype);
+  }
+}
+if (NATIVE_ARRAY_BUFFER_VIEWS && getPrototypeOf(Uint8ClampedArrayPrototype) !== TypedArrayPrototype) {
+ setPrototypeOf(Uint8ClampedArrayPrototype, TypedArrayPrototype);
+}
+if (DESCRIPTORS && !has(TypedArrayPrototype, TO_STRING_TAG)) {
+ TYPED_ARRAY_TAG_REQIRED = true;
+ defineProperty(TypedArrayPrototype, TO_STRING_TAG, {
+  get: function () {
+   return isObject(this) ? this[TYPED_ARRAY_TAG] : undefined;
+  }
+ });
+ for (NAME in TypedArrayConstructorsList)
+  if (global[NAME]) {
+   createNonEnumerableProperty(global[NAME], TYPED_ARRAY_TAG, NAME);
+  }
+}
+module.exports = {
+ NATIVE_ARRAY_BUFFER_VIEWS: NATIVE_ARRAY_BUFFER_VIEWS,
+ TYPED_ARRAY_TAG: TYPED_ARRAY_TAG_REQIRED && TYPED_ARRAY_TAG,
+ aTypedArray: aTypedArray,
+ aTypedArrayConstructor: aTypedArrayConstructor,
+ exportTypedArrayMethod: exportTypedArrayMethod,
+ exportTypedArrayStaticMethod: exportTypedArrayStaticMethod,
+ isView: isView,
+ isTypedArray: isTypedArray,
+ TypedArray: TypedArray,
+ TypedArrayPrototype: TypedArrayPrototype
+};
+
+/***/ }),
+/* 111 */
+/***/ (function(module, exports) {
+
+module.exports = typeof ArrayBuffer !== 'undefined' && typeof DataView !== 'undefined';
+
+/***/ }),
+/* 112 */
+/***/ (function(module, exports, __w_pdfjs_require__) {
+
+var anObject = __w_pdfjs_require__(28);
+var aFunction = __w_pdfjs_require__(63);
+var wellKnownSymbol = __w_pdfjs_require__(57);
+var SPECIES = wellKnownSymbol('species');
+module.exports = function (O, defaultConstructor) {
+ var C = anObject(O).constructor;
+ var S;
+ return C === undefined || (S = anObject(C)[SPECIES]) == undefined ? defaultConstructor : aFunction(S);
+};
+
+/***/ }),
+/* 113 */
+/***/ (function(module, exports, __w_pdfjs_require__) {
+
+__w_pdfjs_require__(114);
+__w_pdfjs_require__(77);
+__w_pdfjs_require__(116);
+__w_pdfjs_require__(119);
+__w_pdfjs_require__(134);
+__w_pdfjs_require__(135);
+var path = __w_pdfjs_require__(43);
+module.exports = path.Promise;
+
+/***/ }),
+/* 114 */
+/***/ (function(module, exports, __w_pdfjs_require__) {
+
+var TO_STRING_TAG_SUPPORT = __w_pdfjs_require__(96);
+var redefine = __w_pdfjs_require__(29);
+var toString = __w_pdfjs_require__(115);
+if (!TO_STRING_TAG_SUPPORT) {
+ redefine(Object.prototype, 'toString', toString, { unsafe: true });
+}
+
+/***/ }),
+/* 115 */
+/***/ (function(module, exports, __w_pdfjs_require__) {
+
+"use strict";
+
+var TO_STRING_TAG_SUPPORT = __w_pdfjs_require__(96);
+var classof = __w_pdfjs_require__(95);
+module.exports = TO_STRING_TAG_SUPPORT ? {}.toString : function toString() {
+ return '[object ' + classof(this) + ']';
+};
+
+/***/ }),
+/* 116 */
+/***/ (function(module, exports, __w_pdfjs_require__) {
+
+var global = __w_pdfjs_require__(11);
+var DOMIterables = __w_pdfjs_require__(117);
+var ArrayIteratorMethods = __w_pdfjs_require__(118);
+var createNonEnumerableProperty = __w_pdfjs_require__(26);
+var wellKnownSymbol = __w_pdfjs_require__(57);
+var ITERATOR = wellKnownSymbol('iterator');
+var TO_STRING_TAG = wellKnownSymbol('toStringTag');
+var ArrayValues = ArrayIteratorMethods.values;
+for (var COLLECTION_NAME in DOMIterables) {
+ var Collection = global[COLLECTION_NAME];
+ var CollectionPrototype = Collection && Collection.prototype;
+ if (CollectionPrototype) {
+  if (CollectionPrototype[ITERATOR] !== ArrayValues)
+   try {
+    createNonEnumerableProperty(CollectionPrototype, ITERATOR, ArrayValues);
+   } catch (error) {
+    CollectionPrototype[ITERATOR] = ArrayValues;
+   }
+  if (!CollectionPrototype[TO_STRING_TAG]) {
+   createNonEnumerableProperty(CollectionPrototype, TO_STRING_TAG, COLLECTION_NAME);
+  }
+  if (DOMIterables[COLLECTION_NAME])
+   for (var METHOD_NAME in ArrayIteratorMethods) {
+    if (CollectionPrototype[METHOD_NAME] !== ArrayIteratorMethods[METHOD_NAME])
+     try {
+      createNonEnumerableProperty(CollectionPrototype, METHOD_NAME, ArrayIteratorMethods[METHOD_NAME]);
+     } catch (error) {
+      CollectionPrototype[METHOD_NAME] = ArrayIteratorMethods[METHOD_NAME];
+     }
+   }
+ }
+}
+
+/***/ }),
+/* 117 */
+/***/ (function(module, exports) {
+
+module.exports = {
+ CSSRuleList: 0,
+ CSSStyleDeclaration: 0,
+ CSSValueList: 0,
+ ClientRectList: 0,
+ DOMRectList: 0,
+ DOMStringList: 0,
+ DOMTokenList: 1,
+ DataTransferItemList: 0,
+ FileList: 0,
+ HTMLAllCollection: 0,
+ HTMLCollection: 0,
+ HTMLFormElement: 0,
+ HTMLSelectElement: 0,
+ MediaList: 0,
+ MimeTypeArray: 0,
+ NamedNodeMap: 0,
+ NodeList: 1,
+ PaintRequestList: 0,
+ Plugin: 0,
+ PluginArray: 0,
+ SVGLengthList: 0,
+ SVGNumberList: 0,
+ SVGPathSegList: 0,
+ SVGPointList: 0,
+ SVGStringList: 0,
+ SVGTransformList: 0,
+ SourceBufferList: 0,
+ StyleSheetList: 0,
+ TextTrackCueList: 0,
+ TextTrackList: 0,
+ TouchList: 0
+};
+
+/***/ }),
+/* 118 */
+/***/ (function(module, exports, __w_pdfjs_require__) {
+
+"use strict";
+
+var toIndexedObject = __w_pdfjs_require__(17);
+var addToUnscopables = __w_pdfjs_require__(70);
+var Iterators = __w_pdfjs_require__(86);
+var InternalStateModule = __w_pdfjs_require__(33);
+var defineIterator = __w_pdfjs_require__(79);
+var ARRAY_ITERATOR = 'Array Iterator';
+var setInternalState = InternalStateModule.set;
+var getInternalState = InternalStateModule.getterFor(ARRAY_ITERATOR);
+module.exports = defineIterator(Array, 'Array', function (iterated, kind) {
+ setInternalState(this, {
+  type: ARRAY_ITERATOR,
+  target: toIndexedObject(iterated),
+  index: 0,
+  kind: kind
+ });
+}, function () {
+ var state = getInternalState(this);
+ var target = state.target;
+ var kind = state.kind;
+ var index = state.index++;
+ if (!target || index >= target.length) {
+  state.target = undefined;
+  return {
+   value: undefined,
+   done: true
+  };
+ }
+ if (kind == 'keys')
+  return {
+   value: index,
+   done: false
+  };
+ if (kind == 'values')
+  return {
+   value: target[index],
+   done: false
+  };
+ return {
+  value: [
+   index,
+   target[index]
+  ],
+  done: false
+ };
+}, 'values');
+Iterators.Arguments = Iterators.Array;
+addToUnscopables('keys');
+addToUnscopables('values');
+addToUnscopables('entries');
+
+/***/ }),
+/* 119 */
+/***/ (function(module, exports, __w_pdfjs_require__) {
+
+"use strict";
+
+var $ = __w_pdfjs_require__(10);
+var IS_PURE = __w_pdfjs_require__(37);
+var global = __w_pdfjs_require__(11);
+var getBuiltIn = __w_pdfjs_require__(42);
+var NativePromise = __w_pdfjs_require__(120);
+var redefine = __w_pdfjs_require__(29);
+var redefineAll = __w_pdfjs_require__(121);
+var setToStringTag = __w_pdfjs_require__(85);
+var setSpecies = __w_pdfjs_require__(122);
+var isObject = __w_pdfjs_require__(22);
+var aFunction = __w_pdfjs_require__(63);
+var anInstance = __w_pdfjs_require__(123);
+var classof = __w_pdfjs_require__(19);
+var inspectSource = __w_pdfjs_require__(31);
+var iterate = __w_pdfjs_require__(124);
+var checkCorrectnessOfIteration = __w_pdfjs_require__(97);
+var speciesConstructor = __w_pdfjs_require__(112);
+var task = __w_pdfjs_require__(125).set;
+var microtask = __w_pdfjs_require__(128);
+var promiseResolve = __w_pdfjs_require__(129);
+var hostReportErrors = __w_pdfjs_require__(131);
+var newPromiseCapabilityModule = __w_pdfjs_require__(130);
+var perform = __w_pdfjs_require__(132);
+var InternalStateModule = __w_pdfjs_require__(33);
+var isForced = __w_pdfjs_require__(52);
+var wellKnownSymbol = __w_pdfjs_require__(57);
+var V8_VERSION = __w_pdfjs_require__(133);
+var SPECIES = wellKnownSymbol('species');
+var PROMISE = 'Promise';
+var getInternalState = InternalStateModule.get;
+var setInternalState = InternalStateModule.set;
+var getInternalPromiseState = InternalStateModule.getterFor(PROMISE);
+var PromiseConstructor = NativePromise;
+var TypeError = global.TypeError;
+var document = global.document;
+var process = global.process;
+var $fetch = getBuiltIn('fetch');
+var newPromiseCapability = newPromiseCapabilityModule.f;
+var newGenericPromiseCapability = newPromiseCapability;
+var IS_NODE = classof(process) == 'process';
+var DISPATCH_EVENT = !!(document && document.createEvent && global.dispatchEvent);
+var UNHANDLED_REJECTION = 'unhandledrejection';
+var REJECTION_HANDLED = 'rejectionhandled';
+var PENDING = 0;
+var FULFILLED = 1;
+var REJECTED = 2;
+var HANDLED = 1;
+var UNHANDLED = 2;
+var Internal, OwnPromiseCapability, PromiseWrapper, nativeThen;
+var FORCED = isForced(PROMISE, function () {
+ var GLOBAL_CORE_JS_PROMISE = inspectSource(PromiseConstructor) !== String(PromiseConstructor);
+ if (!GLOBAL_CORE_JS_PROMISE) {
+  if (V8_VERSION === 66)
+   return true;
+  if (!IS_NODE && typeof PromiseRejectionEvent != 'function')
+   return true;
+ }
+ if (IS_PURE && !PromiseConstructor.prototype['finally'])
+  return true;
+ if (V8_VERSION >= 51 && /native code/.test(PromiseConstructor))
+  return false;
+ var promise = PromiseConstructor.resolve(1);
+ var FakePromise = function (exec) {
+  exec(function () {
+  }, function () {
+  });
+ };
+ var constructor = promise.constructor = {};
+ constructor[SPECIES] = FakePromise;
+ return !(promise.then(function () {
+ }) instanceof FakePromise);
+});
+var INCORRECT_ITERATION = FORCED || !checkCorrectnessOfIteration(function (iterable) {
+ PromiseConstructor.all(iterable)['catch'](function () {
+ });
+});
+var isThenable = function (it) {
+ var then;
+ return isObject(it) && typeof (then = it.then) == 'function' ? then : false;
+};
+var notify = function (promise, state, isReject) {
+ if (state.notified)
+  return;
+ state.notified = true;
+ var chain = state.reactions;
+ microtask(function () {
+  var value = state.value;
+  var ok = state.state == FULFILLED;
+  var index = 0;
+  while (chain.length > index) {
+   var reaction = chain[index++];
+   var handler = ok ? reaction.ok : reaction.fail;
+   var resolve = reaction.resolve;
+   var reject = reaction.reject;
+   var domain = reaction.domain;
+   var result, then, exited;
+   try {
+    if (handler) {
+     if (!ok) {
+      if (state.rejection === UNHANDLED)
+       onHandleUnhandled(promise, state);
+      state.rejection = HANDLED;
+     }
+     if (handler === true)
+      result = value;
+     else {
+      if (domain)
+       domain.enter();
+      result = handler(value);
+      if (domain) {
+       domain.exit();
+       exited = true;
+      }
+     }
+     if (result === reaction.promise) {
+      reject(TypeError('Promise-chain cycle'));
+     } else if (then = isThenable(result)) {
+      then.call(result, resolve, reject);
+     } else
+      resolve(result);
+    } else
+     reject(value);
+   } catch (error) {
+    if (domain && !exited)
+     domain.exit();
+    reject(error);
+   }
+  }
+  state.reactions = [];
+  state.notified = false;
+  if (isReject && !state.rejection)
+   onUnhandled(promise, state);
+ });
+};
+var dispatchEvent = function (name, promise, reason) {
+ var event, handler;
+ if (DISPATCH_EVENT) {
+  event = document.createEvent('Event');
+  event.promise = promise;
+  event.reason = reason;
+  event.initEvent(name, false, true);
+  global.dispatchEvent(event);
+ } else
+  event = {
+   promise: promise,
+   reason: reason
+  };
+ if (handler = global['on' + name])
+  handler(event);
+ else if (name === UNHANDLED_REJECTION)
+  hostReportErrors('Unhandled promise rejection', reason);
+};
+var onUnhandled = function (promise, state) {
+ task.call(global, function () {
+  var value = state.value;
+  var IS_UNHANDLED = isUnhandled(state);
+  var result;
+  if (IS_UNHANDLED) {
+   result = perform(function () {
+    if (IS_NODE) {
+     process.emit('unhandledRejection', value, promise);
+    } else
+     dispatchEvent(UNHANDLED_REJECTION, promise, value);
+   });
+   state.rejection = IS_NODE || isUnhandled(state) ? UNHANDLED : HANDLED;
+   if (result.error)
+    throw result.value;
+  }
+ });
+};
+var isUnhandled = function (state) {
+ return state.rejection !== HANDLED && !state.parent;
+};
+var onHandleUnhandled = function (promise, state) {
+ task.call(global, function () {
+  if (IS_NODE) {
+   process.emit('rejectionHandled', promise);
+  } else
+   dispatchEvent(REJECTION_HANDLED, promise, state.value);
+ });
+};
+var bind = function (fn, promise, state, unwrap) {
+ return function (value) {
+  fn(promise, state, value, unwrap);
+ };
+};
+var internalReject = function (promise, state, value, unwrap) {
+ if (state.done)
+  return;
+ state.done = true;
+ if (unwrap)
+  state = unwrap;
+ state.value = value;
+ state.state = REJECTED;
+ notify(promise, state, true);
+};
+var internalResolve = function (promise, state, value, unwrap) {
+ if (state.done)
+  return;
+ state.done = true;
+ if (unwrap)
+  state = unwrap;
+ try {
+  if (promise === value)
+   throw TypeError("Promise can't be resolved itself");
+  var then = isThenable(value);
+  if (then) {
+   microtask(function () {
+    var wrapper = { done: false };
+    try {
+     then.call(value, bind(internalResolve, promise, wrapper, state), bind(internalReject, promise, wrapper, state));
+    } catch (error) {
+     internalReject(promise, wrapper, error, state);
+    }
+   });
+  } else {
+   state.value = value;
+   state.state = FULFILLED;
+   notify(promise, state, false);
+  }
+ } catch (error) {
+  internalReject(promise, { done: false }, error, state);
+ }
+};
+if (FORCED) {
+ PromiseConstructor = function Promise(executor) {
+  anInstance(this, PromiseConstructor, PROMISE);
+  aFunction(executor);
+  Internal.call(this);
+  var state = getInternalState(this);
+  try {
+   executor(bind(internalResolve, this, state), bind(internalReject, this, state));
+  } catch (error) {
+   internalReject(this, state, error);
+  }
+ };
+ Internal = function Promise(executor) {
+  setInternalState(this, {
+   type: PROMISE,
+   done: false,
+   notified: false,
+   parent: false,
+   reactions: [],
+   rejection: false,
+   state: PENDING,
+   value: undefined
+  });
+ };
+ Internal.prototype = redefineAll(PromiseConstructor.prototype, {
+  then: function then(onFulfilled, onRejected) {
+   var state = getInternalPromiseState(this);
+   var reaction = newPromiseCapability(speciesConstructor(this, PromiseConstructor));
+   reaction.ok = typeof onFulfilled == 'function' ? onFulfilled : true;
+   reaction.fail = typeof onRejected == 'function' && onRejected;
+   reaction.domain = IS_NODE ? process.domain : undefined;
+   state.parent = true;
+   state.reactions.push(reaction);
+   if (state.state != PENDING)
+    notify(this, state, false);
+   return reaction.promise;
+  },
+  'catch': function (onRejected) {
+   return this.then(undefined, onRejected);
+  }
+ });
+ OwnPromiseCapability = function () {
+  var promise = new Internal();
+  var state = getInternalState(promise);
+  this.promise = promise;
+  this.resolve = bind(internalResolve, promise, state);
+  this.reject = bind(internalReject, promise, state);
+ };
+ newPromiseCapabilityModule.f = newPromiseCapability = function (C) {
+  return C === PromiseConstructor || C === PromiseWrapper ? new OwnPromiseCapability(C) : newGenericPromiseCapability(C);
+ };
+ if (!IS_PURE && typeof NativePromise == 'function') {
+  nativeThen = NativePromise.prototype.then;
+  redefine(NativePromise.prototype, 'then', function then(onFulfilled, onRejected) {
+   var that = this;
+   return new PromiseConstructor(function (resolve, reject) {
+    nativeThen.call(that, resolve, reject);
+   }).then(onFulfilled, onRejected);
+  }, { unsafe: true });
+  if (typeof $fetch == 'function')
+   $({
+    global: true,
+    enumerable: true,
+    forced: true
+   }, {
+    fetch: function fetch(input) {
+     return promiseResolve(PromiseConstructor, $fetch.apply(global, arguments));
+    }
+   });
+ }
+}
+$({
+ global: true,
+ wrap: true,
+ forced: FORCED
+}, { Promise: PromiseConstructor });
+setToStringTag(PromiseConstructor, PROMISE, false, true);
+setSpecies(PROMISE);
+PromiseWrapper = getBuiltIn(PROMISE);
+$({
+ target: PROMISE,
+ stat: true,
+ forced: FORCED
+}, {
+ reject: function reject(r) {
+  var capability = newPromiseCapability(this);
+  capability.reject.call(undefined, r);
+  return capability.promise;
+ }
+});
+$({
+ target: PROMISE,
+ stat: true,
+ forced: IS_PURE || FORCED
+}, {
+ resolve: function resolve(x) {
+  return promiseResolve(IS_PURE && this === PromiseWrapper ? PromiseConstructor : this, x);
+ }
+});
+$({
+ target: PROMISE,
+ stat: true,
+ forced: INCORRECT_ITERATION
+}, {
+ all: function all(iterable) {
+  var C = this;
+  var capability = newPromiseCapability(C);
+  var resolve = capability.resolve;
+  var reject = capability.reject;
+  var result = perform(function () {
+   var $promiseResolve = aFunction(C.resolve);
+   var values = [];
+   var counter = 0;
+   var remaining = 1;
+   iterate(iterable, function (promise) {
+    var index = counter++;
+    var alreadyCalled = false;
+    values.push(undefined);
+    remaining++;
+    $promiseResolve.call(C, promise).then(function (value) {
+     if (alreadyCalled)
+      return;
+     alreadyCalled = true;
+     values[index] = value;
+     --remaining || resolve(values);
+    }, reject);
+   });
+   --remaining || resolve(values);
+  });
+  if (result.error)
+   reject(result.value);
+  return capability.promise;
+ },
+ race: function race(iterable) {
+  var C = this;
+  var capability = newPromiseCapability(C);
+  var reject = capability.reject;
+  var result = perform(function () {
+   var $promiseResolve = aFunction(C.resolve);
+   iterate(iterable, function (promise) {
+    $promiseResolve.call(C, promise).then(capability.resolve, reject);
+   });
+  });
+  if (result.error)
+   reject(result.value);
+  return capability.promise;
+ }
+});
+
+/***/ }),
+/* 120 */
+/***/ (function(module, exports, __w_pdfjs_require__) {
+
+var global = __w_pdfjs_require__(11);
+module.exports = global.Promise;
+
+/***/ }),
+/* 121 */
+/***/ (function(module, exports, __w_pdfjs_require__) {
+
+var redefine = __w_pdfjs_require__(29);
+module.exports = function (target, src, options) {
+ for (var key in src)
+  redefine(target, key, src[key], options);
+ return target;
+};
+
+/***/ }),
+/* 122 */
+/***/ (function(module, exports, __w_pdfjs_require__) {
+
+"use strict";
+
+var getBuiltIn = __w_pdfjs_require__(42);
+var definePropertyModule = __w_pdfjs_require__(27);
+var wellKnownSymbol = __w_pdfjs_require__(57);
+var DESCRIPTORS = __w_pdfjs_require__(13);
+var SPECIES = wellKnownSymbol('species');
+module.exports = function (CONSTRUCTOR_NAME) {
+ var Constructor = getBuiltIn(CONSTRUCTOR_NAME);
+ var defineProperty = definePropertyModule.f;
+ if (DESCRIPTORS && Constructor && !Constructor[SPECIES]) {
+  defineProperty(Constructor, SPECIES, {
+   configurable: true,
+   get: function () {
+    return this;
+   }
+  });
+ }
+};
+
+/***/ }),
+/* 123 */
+/***/ (function(module, exports) {
+
+module.exports = function (it, Constructor, name) {
+ if (!(it instanceof Constructor)) {
+  throw TypeError('Incorrect ' + (name ? name + ' ' : '') + 'invocation');
+ }
+ return it;
+};
+
+/***/ }),
+/* 124 */
+/***/ (function(module, exports, __w_pdfjs_require__) {
+
+var anObject = __w_pdfjs_require__(28);
+var isArrayIteratorMethod = __w_pdfjs_require__(92);
+var toLength = __w_pdfjs_require__(47);
+var bind = __w_pdfjs_require__(62);
+var getIteratorMethod = __w_pdfjs_require__(94);
+var callWithSafeIterationClosing = __w_pdfjs_require__(91);
+var Result = function (stopped, result) {
+ this.stopped = stopped;
+ this.result = result;
+};
+var iterate = module.exports = function (iterable, fn, that, AS_ENTRIES, IS_ITERATOR) {
+ var boundFunction = bind(fn, that, AS_ENTRIES ? 2 : 1);
+ var iterator, iterFn, index, length, result, next, step;
+ if (IS_ITERATOR) {
+  iterator = iterable;
+ } else {
+  iterFn = getIteratorMethod(iterable);
+  if (typeof iterFn != 'function')
+   throw TypeError('Target is not iterable');
+  if (isArrayIteratorMethod(iterFn)) {
+   for (index = 0, length = toLength(iterable.length); length > index; index++) {
+    result = AS_ENTRIES ? boundFunction(anObject(step = iterable[index])[0], step[1]) : boundFunction(iterable[index]);
+    if (result && result instanceof Result)
+     return result;
+   }
+   return new Result(false);
+  }
+  iterator = iterFn.call(iterable);
+ }
+ next = iterator.next;
+ while (!(step = next.call(iterator)).done) {
+  result = callWithSafeIterationClosing(iterator, boundFunction, step.value, AS_ENTRIES);
+  if (typeof result == 'object' && result && result instanceof Result)
+   return result;
+ }
+ return new Result(false);
+};
+iterate.stop = function (result) {
+ return new Result(true, result);
+};
+
+/***/ }),
+/* 125 */
+/***/ (function(module, exports, __w_pdfjs_require__) {
+
+var global = __w_pdfjs_require__(11);
+var fails = __w_pdfjs_require__(14);
+var classof = __w_pdfjs_require__(19);
+var bind = __w_pdfjs_require__(62);
+var html = __w_pdfjs_require__(74);
+var createElement = __w_pdfjs_require__(25);
+var IS_IOS = __w_pdfjs_require__(126);
+var location = global.location;
+var set = global.setImmediate;
+var clear = global.clearImmediate;
+var process = global.process;
+var MessageChannel = global.MessageChannel;
+var Dispatch = global.Dispatch;
+var counter = 0;
+var queue = {};
+var ONREADYSTATECHANGE = 'onreadystatechange';
+var defer, channel, port;
+var run = function (id) {
+ if (queue.hasOwnProperty(id)) {
+  var fn = queue[id];
+  delete queue[id];
+  fn();
+ }
+};
+var runner = function (id) {
+ return function () {
+  run(id);
+ };
+};
+var listener = function (event) {
+ run(event.data);
+};
+var post = function (id) {
+ global.postMessage(id + '', location.protocol + '//' + location.host);
+};
+if (!set || !clear) {
+ set = function setImmediate(fn) {
+  var args = [];
+  var i = 1;
+  while (arguments.length > i)
+   args.push(arguments[i++]);
+  queue[++counter] = function () {
+   (typeof fn == 'function' ? fn : Function(fn)).apply(undefined, args);
+  };
+  defer(counter);
+  return counter;
+ };
+ clear = function clearImmediate(id) {
+  delete queue[id];
+ };
+ if (classof(process) == 'process') {
+  defer = function (id) {
+   process.nextTick(runner(id));
+  };
+ } else if (Dispatch && Dispatch.now) {
+  defer = function (id) {
+   Dispatch.now(runner(id));
+  };
+ } else if (MessageChannel && !IS_IOS) {
+  channel = new MessageChannel();
+  port = channel.port2;
+  channel.port1.onmessage = listener;
+  defer = bind(port.postMessage, port, 1);
+ } else if (global.addEventListener && typeof postMessage == 'function' && !global.importScripts && !fails(post) && location.protocol !== 'file:') {
+  defer = post;
+  global.addEventListener('message', listener, false);
+ } else if (ONREADYSTATECHANGE in createElement('script')) {
+  defer = function (id) {
+   html.appendChild(createElement('script'))[ONREADYSTATECHANGE] = function () {
+    html.removeChild(this);
+    run(id);
+   };
+  };
+ } else {
+  defer = function (id) {
+   setTimeout(runner(id), 0);
+  };
+ }
+}
+module.exports = {
+ set: set,
+ clear: clear
+};
+
+/***/ }),
+/* 126 */
+/***/ (function(module, exports, __w_pdfjs_require__) {
+
+var userAgent = __w_pdfjs_require__(127);
+module.exports = /(iphone|ipod|ipad).*applewebkit/i.test(userAgent);
+
+/***/ }),
+/* 127 */
+/***/ (function(module, exports, __w_pdfjs_require__) {
+
+var getBuiltIn = __w_pdfjs_require__(42);
+module.exports = getBuiltIn('navigator', 'userAgent') || '';
+
+/***/ }),
+/* 128 */
+/***/ (function(module, exports, __w_pdfjs_require__) {
+
+var global = __w_pdfjs_require__(11);
+var getOwnPropertyDescriptor = __w_pdfjs_require__(12).f;
+var classof = __w_pdfjs_require__(19);
+var macrotask = __w_pdfjs_require__(125).set;
+var IS_IOS = __w_pdfjs_require__(126);
+var MutationObserver = global.MutationObserver || global.WebKitMutationObserver;
+var process = global.process;
+var Promise = global.Promise;
+var IS_NODE = classof(process) == 'process';
+var queueMicrotaskDescriptor = getOwnPropertyDescriptor(global, 'queueMicrotask');
+var queueMicrotask = queueMicrotaskDescriptor && queueMicrotaskDescriptor.value;
+var flush, head, last, notify, toggle, node, promise, then;
+if (!queueMicrotask) {
+ flush = function () {
+  var parent, fn;
+  if (IS_NODE && (parent = process.domain))
+   parent.exit();
+  while (head) {
+   fn = head.fn;
+   head = head.next;
+   try {
+    fn();
+   } catch (error) {
+    if (head)
+     notify();
+    else
+     last = undefined;
+    throw error;
+   }
+  }
+  last = undefined;
+  if (parent)
+   parent.enter();
+ };
+ if (IS_NODE) {
+  notify = function () {
+   process.nextTick(flush);
+  };
+ } else if (MutationObserver && !IS_IOS) {
+  toggle = true;
+  node = document.createTextNode('');
+  new MutationObserver(flush).observe(node, { characterData: true });
+  notify = function () {
+   node.data = toggle = !toggle;
+  };
+ } else if (Promise && Promise.resolve) {
+  promise = Promise.resolve(undefined);
+  then = promise.then;
+  notify = function () {
+   then.call(promise, flush);
+  };
+ } else {
+  notify = function () {
+   macrotask.call(global, flush);
+  };
+ }
+}
+module.exports = queueMicrotask || function (fn) {
+ var task = {
+  fn: fn,
+  next: undefined
+ };
+ if (last)
+  last.next = task;
+ if (!head) {
+  head = task;
+  notify();
+ }
+ last = task;
+};
+
+/***/ }),
+/* 129 */
+/***/ (function(module, exports, __w_pdfjs_require__) {
+
+var anObject = __w_pdfjs_require__(28);
+var isObject = __w_pdfjs_require__(22);
+var newPromiseCapability = __w_pdfjs_require__(130);
+module.exports = function (C, x) {
+ anObject(C);
+ if (isObject(x) && x.constructor === C)
+  return x;
+ var promiseCapability = newPromiseCapability.f(C);
+ var resolve = promiseCapability.resolve;
+ resolve(x);
+ return promiseCapability.promise;
+};
+
+/***/ }),
+/* 130 */
+/***/ (function(module, exports, __w_pdfjs_require__) {
+
+"use strict";
+
+var aFunction = __w_pdfjs_require__(63);
+var PromiseCapability = function (C) {
+ var resolve, reject;
+ this.promise = new C(function ($$resolve, $$reject) {
+  if (resolve !== undefined || reject !== undefined)
+   throw TypeError('Bad Promise constructor');
+  resolve = $$resolve;
+  reject = $$reject;
+ });
+ this.resolve = aFunction(resolve);
+ this.reject = aFunction(reject);
+};
+module.exports.f = function (C) {
+ return new PromiseCapability(C);
+};
+
+/***/ }),
+/* 131 */
+/***/ (function(module, exports, __w_pdfjs_require__) {
+
+var global = __w_pdfjs_require__(11);
+module.exports = function (a, b) {
+ var console = global.console;
+ if (console && console.error) {
+  arguments.length === 1 ? console.error(a) : console.error(a, b);
+ }
+};
+
+/***/ }),
+/* 132 */
+/***/ (function(module, exports) {
+
+module.exports = function (exec) {
+ try {
+  return {
+   error: false,
+   value: exec()
+  };
+ } catch (error) {
+  return {
+   error: true,
+   value: error
+  };
+ }
+};
+
+/***/ }),
+/* 133 */
+/***/ (function(module, exports, __w_pdfjs_require__) {
+
+var global = __w_pdfjs_require__(11);
+var userAgent = __w_pdfjs_require__(127);
+var process = global.process;
+var versions = process && process.versions;
+var v8 = versions && versions.v8;
+var match, version;
+if (v8) {
+ match = v8.split('.');
+ version = match[0] + match[1];
+} else if (userAgent) {
+ match = userAgent.match(/Edge\/(\d+)/);
+ if (!match || match[1] >= 74) {
+  match = userAgent.match(/Chrome\/(\d+)/);
+  if (match)
+   version = match[1];
+ }
+}
+module.exports = version && +version;
+
+/***/ }),
+/* 134 */
+/***/ (function(module, exports, __w_pdfjs_require__) {
+
+"use strict";
+
+var $ = __w_pdfjs_require__(10);
+var aFunction = __w_pdfjs_require__(63);
+var newPromiseCapabilityModule = __w_pdfjs_require__(130);
+var perform = __w_pdfjs_require__(132);
+var iterate = __w_pdfjs_require__(124);
+$({
+ target: 'Promise',
+ stat: true
+}, {
+ allSettled: function allSettled(iterable) {
+  var C = this;
+  var capability = newPromiseCapabilityModule.f(C);
+  var resolve = capability.resolve;
+  var reject = capability.reject;
+  var result = perform(function () {
+   var promiseResolve = aFunction(C.resolve);
+   var values = [];
+   var counter = 0;
+   var remaining = 1;
+   iterate(iterable, function (promise) {
+    var index = counter++;
+    var alreadyCalled = false;
+    values.push(undefined);
+    remaining++;
+    promiseResolve.call(C, promise).then(function (value) {
+     if (alreadyCalled)
+      return;
+     alreadyCalled = true;
+     values[index] = {
+      status: 'fulfilled',
+      value: value
+     };
+     --remaining || resolve(values);
+    }, function (e) {
+     if (alreadyCalled)
+      return;
+     alreadyCalled = true;
+     values[index] = {
+      status: 'rejected',
+      reason: e
+     };
+     --remaining || resolve(values);
+    });
+   });
+   --remaining || resolve(values);
+  });
+  if (result.error)
+   reject(result.value);
+  return capability.promise;
+ }
+});
+
+/***/ }),
+/* 135 */
+/***/ (function(module, exports, __w_pdfjs_require__) {
+
+"use strict";
+
+var $ = __w_pdfjs_require__(10);
+var IS_PURE = __w_pdfjs_require__(37);
+var NativePromise = __w_pdfjs_require__(120);
+var fails = __w_pdfjs_require__(14);
+var getBuiltIn = __w_pdfjs_require__(42);
+var speciesConstructor = __w_pdfjs_require__(112);
+var promiseResolve = __w_pdfjs_require__(129);
+var redefine = __w_pdfjs_require__(29);
+var NON_GENERIC = !!NativePromise && fails(function () {
+ NativePromise.prototype['finally'].call({
+  then: function () {
+  }
+ }, function () {
+ });
+});
+$({
+ target: 'Promise',
+ proto: true,
+ real: true,
+ forced: NON_GENERIC
+}, {
+ 'finally': function (onFinally) {
+  var C = speciesConstructor(this, getBuiltIn('Promise'));
+  var isFunction = typeof onFinally == 'function';
+  return this.then(isFunction ? function (x) {
+   return promiseResolve(C, onFinally()).then(function () {
+    return x;
+   });
+  } : onFinally, isFunction ? function (e) {
+   return promiseResolve(C, onFinally()).then(function () {
+    throw e;
+   });
+  } : onFinally);
+ }
+});
+if (!IS_PURE && typeof NativePromise == 'function' && !NativePromise.prototype['finally']) {
+ redefine(NativePromise.prototype, 'finally', getBuiltIn('Promise').prototype['finally']);
+}
+
+/***/ }),
+/* 136 */
+/***/ (function(module, exports, __w_pdfjs_require__) {
+
+__w_pdfjs_require__(137);
+__w_pdfjs_require__(142);
+__w_pdfjs_require__(140);
+var path = __w_pdfjs_require__(43);
+module.exports = path.URL;
+
+/***/ }),
+/* 137 */
+/***/ (function(module, exports, __w_pdfjs_require__) {
+
+"use strict";
+
+__w_pdfjs_require__(77);
+var $ = __w_pdfjs_require__(10);
+var DESCRIPTORS = __w_pdfjs_require__(13);
+var USE_NATIVE_URL = __w_pdfjs_require__(138);
+var global = __w_pdfjs_require__(11);
+var defineProperties = __w_pdfjs_require__(72);
+var redefine = __w_pdfjs_require__(29);
+var anInstance = __w_pdfjs_require__(123);
+var has = __w_pdfjs_require__(23);
+var assign = __w_pdfjs_require__(100);
+var arrayFrom = __w_pdfjs_require__(90);
+var codeAt = __w_pdfjs_require__(78).codeAt;
+var toASCII = __w_pdfjs_require__(139);
+var setToStringTag = __w_pdfjs_require__(85);
+var URLSearchParamsModule = __w_pdfjs_require__(140);
+var InternalStateModule = __w_pdfjs_require__(33);
+var NativeURL = global.URL;
+var URLSearchParams = URLSearchParamsModule.URLSearchParams;
+var getInternalSearchParamsState = URLSearchParamsModule.getState;
+var setInternalState = InternalStateModule.set;
+var getInternalURLState = InternalStateModule.getterFor('URL');
+var floor = Math.floor;
+var pow = Math.pow;
+var INVALID_AUTHORITY = 'Invalid authority';
+var INVALID_SCHEME = 'Invalid scheme';
+var INVALID_HOST = 'Invalid host';
+var INVALID_PORT = 'Invalid port';
+var ALPHA = /[A-Za-z]/;
+var ALPHANUMERIC = /[\d+-.A-Za-z]/;
+var DIGIT = /\d/;
+var HEX_START = /^(0x|0X)/;
+var OCT = /^[0-7]+$/;
+var DEC = /^\d+$/;
+var HEX = /^[\dA-Fa-f]+$/;
+var FORBIDDEN_HOST_CODE_POINT = /[\u0000\u0009\u000A\u000D #%/:?@[\\]]/;
+var FORBIDDEN_HOST_CODE_POINT_EXCLUDING_PERCENT = /[\u0000\u0009\u000A\u000D #/:?@[\\]]/;
+var LEADING_AND_TRAILING_C0_CONTROL_OR_SPACE = /^[\u0000-\u001F ]+|[\u0000-\u001F ]+$/g;
+var TAB_AND_NEW_LINE = /[\u0009\u000A\u000D]/g;
+var EOF;
+var parseHost = function (url, input) {
+ var result, codePoints, index;
+ if (input.charAt(0) == '[') {
+  if (input.charAt(input.length - 1) != ']')
+   return INVALID_HOST;
+  result = parseIPv6(input.slice(1, -1));
+  if (!result)
+   return INVALID_HOST;
+  url.host = result;
+ } else if (!isSpecial(url)) {
+  if (FORBIDDEN_HOST_CODE_POINT_EXCLUDING_PERCENT.test(input))
+   return INVALID_HOST;
+  result = '';
+  codePoints = arrayFrom(input);
+  for (index = 0; index < codePoints.length; index++) {
+   result += percentEncode(codePoints[index], C0ControlPercentEncodeSet);
+  }
+  url.host = result;
+ } else {
+  input = toASCII(input);
+  if (FORBIDDEN_HOST_CODE_POINT.test(input))
+   return INVALID_HOST;
+  result = parseIPv4(input);
+  if (result === null)
+   return INVALID_HOST;
+  url.host = result;
+ }
+};
+var parseIPv4 = function (input) {
+ var parts = input.split('.');
+ var partsLength, numbers, index, part, radix, number, ipv4;
+ if (parts.length && parts[parts.length - 1] == '') {
+  parts.pop();
+ }
+ partsLength = parts.length;
+ if (partsLength > 4)
+  return input;
+ numbers = [];
+ for (index = 0; index < partsLength; index++) {
+  part = parts[index];
+  if (part == '')
+   return input;
+  radix = 10;
+  if (part.length > 1 && part.charAt(0) == '0') {
+   radix = HEX_START.test(part) ? 16 : 8;
+   part = part.slice(radix == 8 ? 1 : 2);
+  }
+  if (part === '') {
+   number = 0;
+  } else {
+   if (!(radix == 10 ? DEC : radix == 8 ? OCT : HEX).test(part))
+    return input;
+   number = parseInt(part, radix);
+  }
+  numbers.push(number);
+ }
+ for (index = 0; index < partsLength; index++) {
+  number = numbers[index];
+  if (index == partsLength - 1) {
+   if (number >= pow(256, 5 - partsLength))
+    return null;
+  } else if (number > 255)
+   return null;
+ }
+ ipv4 = numbers.pop();
+ for (index = 0; index < numbers.length; index++) {
+  ipv4 += numbers[index] * pow(256, 3 - index);
+ }
+ return ipv4;
+};
+var parseIPv6 = function (input) {
+ var address = [
+  0,
+  0,
+  0,
+  0,
+  0,
+  0,
+  0,
+  0
+ ];
+ var pieceIndex = 0;
+ var compress = null;
+ var pointer = 0;
+ var value, length, numbersSeen, ipv4Piece, number, swaps, swap;
+ var char = function () {
+  return input.charAt(pointer);
+ };
+ if (char() == ':') {
+  if (input.charAt(1) != ':')
+   return;
+  pointer += 2;
+  pieceIndex++;
+  compress = pieceIndex;
+ }
+ while (char()) {
+  if (pieceIndex == 8)
+   return;
+  if (char() == ':') {
+   if (compress !== null)
+    return;
+   pointer++;
+   pieceIndex++;
+   compress = pieceIndex;
+   continue;
+  }
+  value = length = 0;
+  while (length < 4 && HEX.test(char())) {
+   value = value * 16 + parseInt(char(), 16);
+   pointer++;
+   length++;
+  }
+  if (char() == '.') {
+   if (length == 0)
+    return;
+   pointer -= length;
+   if (pieceIndex > 6)
+    return;
+   numbersSeen = 0;
+   while (char()) {
+    ipv4Piece = null;
+    if (numbersSeen > 0) {
+     if (char() == '.' && numbersSeen < 4)
+      pointer++;
+     else
+      return;
+    }
+    if (!DIGIT.test(char()))
+     return;
+    while (DIGIT.test(char())) {
+     number = parseInt(char(), 10);
+     if (ipv4Piece === null)
+      ipv4Piece = number;
+     else if (ipv4Piece == 0)
+      return;
+     else
+      ipv4Piece = ipv4Piece * 10 + number;
+     if (ipv4Piece > 255)
+      return;
+     pointer++;
+    }
+    address[pieceIndex] = address[pieceIndex] * 256 + ipv4Piece;
+    numbersSeen++;
+    if (numbersSeen == 2 || numbersSeen == 4)
+     pieceIndex++;
+   }
+   if (numbersSeen != 4)
+    return;
+   break;
+  } else if (char() == ':') {
+   pointer++;
+   if (!char())
+    return;
+  } else if (char())
+   return;
+  address[pieceIndex++] = value;
+ }
+ if (compress !== null) {
+  swaps = pieceIndex - compress;
+  pieceIndex = 7;
+  while (pieceIndex != 0 && swaps > 0) {
+   swap = address[pieceIndex];
+   address[pieceIndex--] = address[compress + swaps - 1];
+   address[compress + --swaps] = swap;
+  }
+ } else if (pieceIndex != 8)
+  return;
+ return address;
+};
+var findLongestZeroSequence = function (ipv6) {
+ var maxIndex = null;
+ var maxLength = 1;
+ var currStart = null;
+ var currLength = 0;
+ var index = 0;
+ for (; index < 8; index++) {
+  if (ipv6[index] !== 0) {
+   if (currLength > maxLength) {
+    maxIndex = currStart;
+    maxLength = currLength;
+   }
+   currStart = null;
+   currLength = 0;
+  } else {
+   if (currStart === null)
+    currStart = index;
+   ++currLength;
+  }
+ }
+ if (currLength > maxLength) {
+  maxIndex = currStart;
+  maxLength = currLength;
+ }
+ return maxIndex;
+};
+var serializeHost = function (host) {
+ var result, index, compress, ignore0;
+ if (typeof host == 'number') {
+  result = [];
+  for (index = 0; index < 4; index++) {
+   result.unshift(host % 256);
+   host = floor(host / 256);
+  }
+  return result.join('.');
+ } else if (typeof host == 'object') {
+  result = '';
+  compress = findLongestZeroSequence(host);
+  for (index = 0; index < 8; index++) {
+   if (ignore0 && host[index] === 0)
+    continue;
+   if (ignore0)
+    ignore0 = false;
+   if (compress === index) {
+    result += index ? ':' : '::';
+    ignore0 = true;
+   } else {
+    result += host[index].toString(16);
+    if (index < 7)
+     result += ':';
+   }
+  }
+  return '[' + result + ']';
+ }
+ return host;
+};
+var C0ControlPercentEncodeSet = {};
+var fragmentPercentEncodeSet = assign({}, C0ControlPercentEncodeSet, {
+ ' ': 1,
+ '"': 1,
+ '<': 1,
+ '>': 1,
+ '`': 1
+});
+var pathPercentEncodeSet = assign({}, fragmentPercentEncodeSet, {
+ '#': 1,
+ '?': 1,
+ '{': 1,
+ '}': 1
+});
+var userinfoPercentEncodeSet = assign({}, pathPercentEncodeSet, {
+ '/': 1,
+ ':': 1,
+ ';': 1,
+ '=': 1,
+ '@': 1,
+ '[': 1,
+ '\\': 1,
+ ']': 1,
+ '^': 1,
+ '|': 1
+});
+var percentEncode = function (char, set) {
+ var code = codeAt(char, 0);
+ return code > 0x20 && code < 0x7F && !has(set, char) ? char : encodeURIComponent(char);
+};
+var specialSchemes = {
+ ftp: 21,
+ file: null,
+ http: 80,
+ https: 443,
+ ws: 80,
+ wss: 443
+};
+var isSpecial = function (url) {
+ return has(specialSchemes, url.scheme);
+};
+var includesCredentials = function (url) {
+ return url.username != '' || url.password != '';
+};
+var cannotHaveUsernamePasswordPort = function (url) {
+ return !url.host || url.cannotBeABaseURL || url.scheme == 'file';
+};
+var isWindowsDriveLetter = function (string, normalized) {
+ var second;
+ return string.length == 2 && ALPHA.test(string.charAt(0)) && ((second = string.charAt(1)) == ':' || !normalized && second == '|');
+};
+var startsWithWindowsDriveLetter = function (string) {
+ var third;
+ return string.length > 1 && isWindowsDriveLetter(string.slice(0, 2)) && (string.length == 2 || ((third = string.charAt(2)) === '/' || third === '\\' || third === '?' || third === '#'));
+};
+var shortenURLsPath = function (url) {
+ var path = url.path;
+ var pathSize = path.length;
+ if (pathSize && (url.scheme != 'file' || pathSize != 1 || !isWindowsDriveLetter(path[0], true))) {
+  path.pop();
+ }
+};
+var isSingleDot = function (segment) {
+ return segment === '.' || segment.toLowerCase() === '%2e';
+};
+var isDoubleDot = function (segment) {
+ segment = segment.toLowerCase();
+ return segment === '..' || segment === '%2e.' || segment === '.%2e' || segment === '%2e%2e';
+};
+var SCHEME_START = {};
+var SCHEME = {};
+var NO_SCHEME = {};
+var SPECIAL_RELATIVE_OR_AUTHORITY = {};
+var PATH_OR_AUTHORITY = {};
+var RELATIVE = {};
+var RELATIVE_SLASH = {};
+var SPECIAL_AUTHORITY_SLASHES = {};
+var SPECIAL_AUTHORITY_IGNORE_SLASHES = {};
+var AUTHORITY = {};
+var HOST = {};
+var HOSTNAME = {};
+var PORT = {};
+var FILE = {};
+var FILE_SLASH = {};
+var FILE_HOST = {};
+var PATH_START = {};
+var PATH = {};
+var CANNOT_BE_A_BASE_URL_PATH = {};
+var QUERY = {};
+var FRAGMENT = {};
+var parseURL = function (url, input, stateOverride, base) {
+ var state = stateOverride || SCHEME_START;
+ var pointer = 0;
+ var buffer = '';
+ var seenAt = false;
+ var seenBracket = false;
+ var seenPasswordToken = false;
+ var codePoints, char, bufferCodePoints, failure;
+ if (!stateOverride) {
+  url.scheme = '';
+  url.username = '';
+  url.password = '';
+  url.host = null;
+  url.port = null;
+  url.path = [];
+  url.query = null;
+  url.fragment = null;
+  url.cannotBeABaseURL = false;
+  input = input.replace(LEADING_AND_TRAILING_C0_CONTROL_OR_SPACE, '');
+ }
+ input = input.replace(TAB_AND_NEW_LINE, '');
+ codePoints = arrayFrom(input);
+ while (pointer <= codePoints.length) {
+  char = codePoints[pointer];
+  switch (state) {
+  case SCHEME_START:
+   if (char && ALPHA.test(char)) {
+    buffer += char.toLowerCase();
+    state = SCHEME;
+   } else if (!stateOverride) {
+    state = NO_SCHEME;
+    continue;
+   } else
+    return INVALID_SCHEME;
+   break;
+  case SCHEME:
+   if (char && (ALPHANUMERIC.test(char) || char == '+' || char == '-' || char == '.')) {
+    buffer += char.toLowerCase();
+   } else if (char == ':') {
+    if (stateOverride && (isSpecial(url) != has(specialSchemes, buffer) || buffer == 'file' && (includesCredentials(url) || url.port !== null) || url.scheme == 'file' && !url.host))
+     return;
+    url.scheme = buffer;
+    if (stateOverride) {
+     if (isSpecial(url) && specialSchemes[url.scheme] == url.port)
+      url.port = null;
+     return;
+    }
+    buffer = '';
+    if (url.scheme == 'file') {
+     state = FILE;
+    } else if (isSpecial(url) && base && base.scheme == url.scheme) {
+     state = SPECIAL_RELATIVE_OR_AUTHORITY;
+    } else if (isSpecial(url)) {
+     state = SPECIAL_AUTHORITY_SLASHES;
+    } else if (codePoints[pointer + 1] == '/') {
+     state = PATH_OR_AUTHORITY;
+     pointer++;
+    } else {
+     url.cannotBeABaseURL = true;
+     url.path.push('');
+     state = CANNOT_BE_A_BASE_URL_PATH;
+    }
+   } else if (!stateOverride) {
+    buffer = '';
+    state = NO_SCHEME;
+    pointer = 0;
+    continue;
+   } else
+    return INVALID_SCHEME;
+   break;
+  case NO_SCHEME:
+   if (!base || base.cannotBeABaseURL && char != '#')
+    return INVALID_SCHEME;
+   if (base.cannotBeABaseURL && char == '#') {
+    url.scheme = base.scheme;
+    url.path = base.path.slice();
+    url.query = base.query;
+    url.fragment = '';
+    url.cannotBeABaseURL = true;
+    state = FRAGMENT;
+    break;
+   }
+   state = base.scheme == 'file' ? FILE : RELATIVE;
+   continue;
+  case SPECIAL_RELATIVE_OR_AUTHORITY:
+   if (char == '/' && codePoints[pointer + 1] == '/') {
+    state = SPECIAL_AUTHORITY_IGNORE_SLASHES;
+    pointer++;
+   } else {
+    state = RELATIVE;
+    continue;
+   }
+   break;
+  case PATH_OR_AUTHORITY:
+   if (char == '/') {
+    state = AUTHORITY;
+    break;
+   } else {
+    state = PATH;
+    continue;
+   }
+  case RELATIVE:
+   url.scheme = base.scheme;
+   if (char == EOF) {
+    url.username = base.username;
+    url.password = base.password;
+    url.host = base.host;
+    url.port = base.port;
+    url.path = base.path.slice();
+    url.query = base.query;
+   } else if (char == '/' || char == '\\' && isSpecial(url)) {
+    state = RELATIVE_SLASH;
+   } else if (char == '?') {
+    url.username = base.username;
+    url.password = base.password;
+    url.host = base.host;
+    url.port = base.port;
+    url.path = base.path.slice();
+    url.query = '';
+    state = QUERY;
+   } else if (char == '#') {
+    url.username = base.username;
+    url.password = base.password;
+    url.host = base.host;
+    url.port = base.port;
+    url.path = base.path.slice();
+    url.query = base.query;
+    url.fragment = '';
+    state = FRAGMENT;
+   } else {
+    url.username = base.username;
+    url.password = base.password;
+    url.host = base.host;
+    url.port = base.port;
+    url.path = base.path.slice();
+    url.path.pop();
+    state = PATH;
+    continue;
+   }
+   break;
+  case RELATIVE_SLASH:
+   if (isSpecial(url) && (char == '/' || char == '\\')) {
+    state = SPECIAL_AUTHORITY_IGNORE_SLASHES;
+   } else if (char == '/') {
+    state = AUTHORITY;
+   } else {
+    url.username = base.username;
+    url.password = base.password;
+    url.host = base.host;
+    url.port = base.port;
+    state = PATH;
+    continue;
+   }
+   break;
+  case SPECIAL_AUTHORITY_SLASHES:
+   state = SPECIAL_AUTHORITY_IGNORE_SLASHES;
+   if (char != '/' || buffer.charAt(pointer + 1) != '/')
+    continue;
+   pointer++;
+   break;
+  case SPECIAL_AUTHORITY_IGNORE_SLASHES:
+   if (char != '/' && char != '\\') {
+    state = AUTHORITY;
+    continue;
+   }
+   break;
+  case AUTHORITY:
+   if (char == '@') {
+    if (seenAt)
+     buffer = '%40' + buffer;
+    seenAt = true;
+    bufferCodePoints = arrayFrom(buffer);
+    for (var i = 0; i < bufferCodePoints.length; i++) {
+     var codePoint = bufferCodePoints[i];
+     if (codePoint == ':' && !seenPasswordToken) {
+      seenPasswordToken = true;
+      continue;
+     }
+     var encodedCodePoints = percentEncode(codePoint, userinfoPercentEncodeSet);
+     if (seenPasswordToken)
+      url.password += encodedCodePoints;
+     else
+      url.username += encodedCodePoints;
+    }
+    buffer = '';
+   } else if (char == EOF || char == '/' || char == '?' || char == '#' || char == '\\' && isSpecial(url)) {
+    if (seenAt && buffer == '')
+     return INVALID_AUTHORITY;
+    pointer -= arrayFrom(buffer).length + 1;
+    buffer = '';
+    state = HOST;
+   } else
+    buffer += char;
+   break;
+  case HOST:
+  case HOSTNAME:
+   if (stateOverride && url.scheme == 'file') {
+    state = FILE_HOST;
+    continue;
+   } else if (char == ':' && !seenBracket) {
+    if (buffer == '')
+     return INVALID_HOST;
+    failure = parseHost(url, buffer);
+    if (failure)
+     return failure;
+    buffer = '';
+    state = PORT;
+    if (stateOverride == HOSTNAME)
+     return;
+   } else if (char == EOF || char == '/' || char == '?' || char == '#' || char == '\\' && isSpecial(url)) {
+    if (isSpecial(url) && buffer == '')
+     return INVALID_HOST;
+    if (stateOverride && buffer == '' && (includesCredentials(url) || url.port !== null))
+     return;
+    failure = parseHost(url, buffer);
+    if (failure)
+     return failure;
+    buffer = '';
+    state = PATH_START;
+    if (stateOverride)
+     return;
+    continue;
+   } else {
+    if (char == '[')
+     seenBracket = true;
+    else if (char == ']')
+     seenBracket = false;
+    buffer += char;
+   }
+   break;
+  case PORT:
+   if (DIGIT.test(char)) {
+    buffer += char;
+   } else if (char == EOF || char == '/' || char == '?' || char == '#' || char == '\\' && isSpecial(url) || stateOverride) {
+    if (buffer != '') {
+     var port = parseInt(buffer, 10);
+     if (port > 0xFFFF)
+      return INVALID_PORT;
+     url.port = isSpecial(url) && port === specialSchemes[url.scheme] ? null : port;
+     buffer = '';
+    }
+    if (stateOverride)
+     return;
+    state = PATH_START;
+    continue;
+   } else
+    return INVALID_PORT;
+   break;
+  case FILE:
+   url.scheme = 'file';
+   if (char == '/' || char == '\\')
+    state = FILE_SLASH;
+   else if (base && base.scheme == 'file') {
+    if (char == EOF) {
+     url.host = base.host;
+     url.path = base.path.slice();
+     url.query = base.query;
+    } else if (char == '?') {
+     url.host = base.host;
+     url.path = base.path.slice();
+     url.query = '';
+     state = QUERY;
+    } else if (char == '#') {
+     url.host = base.host;
+     url.path = base.path.slice();
+     url.query = base.query;
+     url.fragment = '';
+     state = FRAGMENT;
+    } else {
+     if (!startsWithWindowsDriveLetter(codePoints.slice(pointer).join(''))) {
+      url.host = base.host;
+      url.path = base.path.slice();
+      shortenURLsPath(url);
+     }
+     state = PATH;
+     continue;
+    }
+   } else {
+    state = PATH;
+    continue;
+   }
+   break;
+  case FILE_SLASH:
+   if (char == '/' || char == '\\') {
+    state = FILE_HOST;
+    break;
+   }
+   if (base && base.scheme == 'file' && !startsWithWindowsDriveLetter(codePoints.slice(pointer).join(''))) {
+    if (isWindowsDriveLetter(base.path[0], true))
+     url.path.push(base.path[0]);
+    else
+     url.host = base.host;
+   }
+   state = PATH;
+   continue;
+  case FILE_HOST:
+   if (char == EOF || char == '/' || char == '\\' || char == '?' || char == '#') {
+    if (!stateOverride && isWindowsDriveLetter(buffer)) {
+     state = PATH;
+    } else if (buffer == '') {
+     url.host = '';
+     if (stateOverride)
+      return;
+     state = PATH_START;
+    } else {
+     failure = parseHost(url, buffer);
+     if (failure)
+      return failure;
+     if (url.host == 'localhost')
+      url.host = '';
+     if (stateOverride)
+      return;
+     buffer = '';
+     state = PATH_START;
+    }
+    continue;
+   } else
+    buffer += char;
+   break;
+  case PATH_START:
+   if (isSpecial(url)) {
+    state = PATH;
+    if (char != '/' && char != '\\')
+     continue;
+   } else if (!stateOverride && char == '?') {
+    url.query = '';
+    state = QUERY;
+   } else if (!stateOverride && char == '#') {
+    url.fragment = '';
+    state = FRAGMENT;
+   } else if (char != EOF) {
+    state = PATH;
+    if (char != '/')
+     continue;
+   }
+   break;
+  case PATH:
+   if (char == EOF || char == '/' || char == '\\' && isSpecial(url) || !stateOverride && (char == '?' || char == '#')) {
+    if (isDoubleDot(buffer)) {
+     shortenURLsPath(url);
+     if (char != '/' && !(char == '\\' && isSpecial(url))) {
+      url.path.push('');
+     }
+    } else if (isSingleDot(buffer)) {
+     if (char != '/' && !(char == '\\' && isSpecial(url))) {
+      url.path.push('');
+     }
+    } else {
+     if (url.scheme == 'file' && !url.path.length && isWindowsDriveLetter(buffer)) {
+      if (url.host)
+       url.host = '';
+      buffer = buffer.charAt(0) + ':';
+     }
+     url.path.push(buffer);
+    }
+    buffer = '';
+    if (url.scheme == 'file' && (char == EOF || char == '?' || char == '#')) {
+     while (url.path.length > 1 && url.path[0] === '') {
+      url.path.shift();
+     }
+    }
+    if (char == '?') {
+     url.query = '';
+     state = QUERY;
+    } else if (char == '#') {
+     url.fragment = '';
+     state = FRAGMENT;
+    }
+   } else {
+    buffer += percentEncode(char, pathPercentEncodeSet);
+   }
+   break;
+  case CANNOT_BE_A_BASE_URL_PATH:
+   if (char == '?') {
+    url.query = '';
+    state = QUERY;
+   } else if (char == '#') {
+    url.fragment = '';
+    state = FRAGMENT;
+   } else if (char != EOF) {
+    url.path[0] += percentEncode(char, C0ControlPercentEncodeSet);
+   }
+   break;
+  case QUERY:
+   if (!stateOverride && char == '#') {
+    url.fragment = '';
+    state = FRAGMENT;
+   } else if (char != EOF) {
+    if (char == "'" && isSpecial(url))
+     url.query += '%27';
+    else if (char == '#')
+     url.query += '%23';
+    else
+     url.query += percentEncode(char, C0ControlPercentEncodeSet);
+   }
+   break;
+  case FRAGMENT:
+   if (char != EOF)
+    url.fragment += percentEncode(char, fragmentPercentEncodeSet);
+   break;
+  }
+  pointer++;
+ }
+};
+var URLConstructor = function URL(url) {
+ var that = anInstance(this, URLConstructor, 'URL');
+ var base = arguments.length > 1 ? arguments[1] : undefined;
+ var urlString = String(url);
+ var state = setInternalState(that, { type: 'URL' });
+ var baseState, failure;
+ if (base !== undefined) {
+  if (base instanceof URLConstructor)
+   baseState = getInternalURLState(base);
+  else {
+   failure = parseURL(baseState = {}, String(base));
+   if (failure)
+    throw TypeError(failure);
+  }
+ }
+ failure = parseURL(state, urlString, null, baseState);
+ if (failure)
+  throw TypeError(failure);
+ var searchParams = state.searchParams = new URLSearchParams();
+ var searchParamsState = getInternalSearchParamsState(searchParams);
+ searchParamsState.updateSearchParams(state.query);
+ searchParamsState.updateURL = function () {
+  state.query = String(searchParams) || null;
+ };
+ if (!DESCRIPTORS) {
+  that.href = serializeURL.call(that);
+  that.origin = getOrigin.call(that);
+  that.protocol = getProtocol.call(that);
+  that.username = getUsername.call(that);
+  that.password = getPassword.call(that);
+  that.host = getHost.call(that);
+  that.hostname = getHostname.call(that);
+  that.port = getPort.call(that);
+  that.pathname = getPathname.call(that);
+  that.search = getSearch.call(that);
+  that.searchParams = getSearchParams.call(that);
+  that.hash = getHash.call(that);
+ }
+};
+var URLPrototype = URLConstructor.prototype;
+var serializeURL = function () {
+ var url = getInternalURLState(this);
+ var scheme = url.scheme;
+ var username = url.username;
+ var password = url.password;
+ var host = url.host;
+ var port = url.port;
+ var path = url.path;
+ var query = url.query;
+ var fragment = url.fragment;
+ var output = scheme + ':';
+ if (host !== null) {
+  output += '//';
+  if (includesCredentials(url)) {
+   output += username + (password ? ':' + password : '') + '@';
+  }
+  output += serializeHost(host);
+  if (port !== null)
+   output += ':' + port;
+ } else if (scheme == 'file')
+  output += '//';
+ output += url.cannotBeABaseURL ? path[0] : path.length ? '/' + path.join('/') : '';
+ if (query !== null)
+  output += '?' + query;
+ if (fragment !== null)
+  output += '#' + fragment;
+ return output;
+};
+var getOrigin = function () {
+ var url = getInternalURLState(this);
+ var scheme = url.scheme;
+ var port = url.port;
+ if (scheme == 'blob')
+  try {
+   return new URL(scheme.path[0]).origin;
+  } catch (error) {
+   return 'null';
+  }
+ if (scheme == 'file' || !isSpecial(url))
+  return 'null';
+ return scheme + '://' + serializeHost(url.host) + (port !== null ? ':' + port : '');
+};
+var getProtocol = function () {
+ return getInternalURLState(this).scheme + ':';
+};
+var getUsername = function () {
+ return getInternalURLState(this).username;
+};
+var getPassword = function () {
+ return getInternalURLState(this).password;
+};
+var getHost = function () {
+ var url = getInternalURLState(this);
+ var host = url.host;
+ var port = url.port;
+ return host === null ? '' : port === null ? serializeHost(host) : serializeHost(host) + ':' + port;
+};
+var getHostname = function () {
+ var host = getInternalURLState(this).host;
+ return host === null ? '' : serializeHost(host);
+};
+var getPort = function () {
+ var port = getInternalURLState(this).port;
+ return port === null ? '' : String(port);
+};
+var getPathname = function () {
+ var url = getInternalURLState(this);
+ var path = url.path;
+ return url.cannotBeABaseURL ? path[0] : path.length ? '/' + path.join('/') : '';
+};
+var getSearch = function () {
+ var query = getInternalURLState(this).query;
+ return query ? '?' + query : '';
+};
+var getSearchParams = function () {
+ return getInternalURLState(this).searchParams;
+};
+var getHash = function () {
+ var fragment = getInternalURLState(this).fragment;
+ return fragment ? '#' + fragment : '';
+};
+var accessorDescriptor = function (getter, setter) {
+ return {
+  get: getter,
+  set: setter,
+  configurable: true,
+  enumerable: true
+ };
+};
+if (DESCRIPTORS) {
+ defineProperties(URLPrototype, {
+  href: accessorDescriptor(serializeURL, function (href) {
+   var url = getInternalURLState(this);
+   var urlString = String(href);
+   var failure = parseURL(url, urlString);
+   if (failure)
+    throw TypeError(failure);
+   getInternalSearchParamsState(url.searchParams).updateSearchParams(url.query);
+  }),
+  origin: accessorDescriptor(getOrigin),
+  protocol: accessorDescriptor(getProtocol, function (protocol) {
+   var url = getInternalURLState(this);
+   parseURL(url, String(protocol) + ':', SCHEME_START);
+  }),
+  username: accessorDescriptor(getUsername, function (username) {
+   var url = getInternalURLState(this);
+   var codePoints = arrayFrom(String(username));
+   if (cannotHaveUsernamePasswordPort(url))
+    return;
+   url.username = '';
+   for (var i = 0; i < codePoints.length; i++) {
+    url.username += percentEncode(codePoints[i], userinfoPercentEncodeSet);
+   }
+  }),
+  password: accessorDescriptor(getPassword, function (password) {
+   var url = getInternalURLState(this);
+   var codePoints = arrayFrom(String(password));
+   if (cannotHaveUsernamePasswordPort(url))
+    return;
+   url.password = '';
+   for (var i = 0; i < codePoints.length; i++) {
+    url.password += percentEncode(codePoints[i], userinfoPercentEncodeSet);
+   }
+  }),
+  host: accessorDescriptor(getHost, function (host) {
+   var url = getInternalURLState(this);
+   if (url.cannotBeABaseURL)
+    return;
+   parseURL(url, String(host), HOST);
+  }),
+  hostname: accessorDescriptor(getHostname, function (hostname) {
+   var url = getInternalURLState(this);
+   if (url.cannotBeABaseURL)
+    return;
+   parseURL(url, String(hostname), HOSTNAME);
+  }),
+  port: accessorDescriptor(getPort, function (port) {
+   var url = getInternalURLState(this);
+   if (cannotHaveUsernamePasswordPort(url))
+    return;
+   port = String(port);
+   if (port == '')
+    url.port = null;
+   else
+    parseURL(url, port, PORT);
+  }),
+  pathname: accessorDescriptor(getPathname, function (pathname) {
+   var url = getInternalURLState(this);
+   if (url.cannotBeABaseURL)
+    return;
+   url.path = [];
+   parseURL(url, pathname + '', PATH_START);
+  }),
+  search: accessorDescriptor(getSearch, function (search) {
+   var url = getInternalURLState(this);
+   search = String(search);
+   if (search == '') {
+    url.query = null;
+   } else {
+    if ('?' == search.charAt(0))
+     search = search.slice(1);
+    url.query = '';
+    parseURL(url, search, QUERY);
+   }
+   getInternalSearchParamsState(url.searchParams).updateSearchParams(url.query);
+  }),
+  searchParams: accessorDescriptor(getSearchParams),
+  hash: accessorDescriptor(getHash, function (hash) {
+   var url = getInternalURLState(this);
+   hash = String(hash);
+   if (hash == '') {
+    url.fragment = null;
+    return;
+   }
+   if ('#' == hash.charAt(0))
+    hash = hash.slice(1);
+   url.fragment = '';
+   parseURL(url, hash, FRAGMENT);
+  })
+ });
+}
+redefine(URLPrototype, 'toJSON', function toJSON() {
+ return serializeURL.call(this);
+}, { enumerable: true });
+redefine(URLPrototype, 'toString', function toString() {
+ return serializeURL.call(this);
+}, { enumerable: true });
+if (NativeURL) {
+ var nativeCreateObjectURL = NativeURL.createObjectURL;
+ var nativeRevokeObjectURL = NativeURL.revokeObjectURL;
+ if (nativeCreateObjectURL)
+  redefine(URLConstructor, 'createObjectURL', function createObjectURL(blob) {
+   return nativeCreateObjectURL.apply(NativeURL, arguments);
+  });
+ if (nativeRevokeObjectURL)
+  redefine(URLConstructor, 'revokeObjectURL', function revokeObjectURL(url) {
+   return nativeRevokeObjectURL.apply(NativeURL, arguments);
+  });
+}
+setToStringTag(URLConstructor, 'URL');
+$({
+ global: true,
+ forced: !USE_NATIVE_URL,
+ sham: !DESCRIPTORS
+}, { URL: URLConstructor });
+
+/***/ }),
+/* 138 */
+/***/ (function(module, exports, __w_pdfjs_require__) {
+
+var fails = __w_pdfjs_require__(14);
+var wellKnownSymbol = __w_pdfjs_require__(57);
+var IS_PURE = __w_pdfjs_require__(37);
+var ITERATOR = wellKnownSymbol('iterator');
+module.exports = !fails(function () {
+ var url = new URL('b?a=1&b=2&c=3', 'http://a');
+ var searchParams = url.searchParams;
+ var result = '';
+ url.pathname = 'c%20d';
+ searchParams.forEach(function (value, key) {
+  searchParams['delete']('b');
+  result += key + value;
+ });
+ return IS_PURE && !url.toJSON || !searchParams.sort || url.href !== 'http://a/c%20d?a=1&c=3' || searchParams.get('c') !== '3' || String(new URLSearchParams('?a=1')) !== 'a=1' || !searchParams[ITERATOR] || new URL('https://a@b').username !== 'a' || new URLSearchParams(new URLSearchParams('a=b')).get('a') !== 'b' || new URL('http://тест').host !== 'xn--e1aybc' || new URL('http://a#б').hash !== '#%D0%B1' || result !== 'a1c3' || new URL('http://x', undefined).host !== 'x';
+});
+
+/***/ }),
+/* 139 */
+/***/ (function(module, exports, __w_pdfjs_require__) {
+
+"use strict";
+
+var maxInt = 2147483647;
+var base = 36;
+var tMin = 1;
+var tMax = 26;
+var skew = 38;
+var damp = 700;
+var initialBias = 72;
+var initialN = 128;
+var delimiter = '-';
+var regexNonASCII = /[^\0-\u007E]/;
+var regexSeparators = /[.\u3002\uFF0E\uFF61]/g;
+var OVERFLOW_ERROR = 'Overflow: input needs wider integers to process';
+var baseMinusTMin = base - tMin;
+var floor = Math.floor;
+var stringFromCharCode = String.fromCharCode;
+var ucs2decode = function (string) {
+ var output = [];
+ var counter = 0;
+ var length = string.length;
+ while (counter < length) {
+  var value = string.charCodeAt(counter++);
+  if (value >= 0xD800 && value <= 0xDBFF && counter < length) {
+   var extra = string.charCodeAt(counter++);
+   if ((extra & 0xFC00) == 0xDC00) {
+    output.push(((value & 0x3FF) << 10) + (extra & 0x3FF) + 0x10000);
+   } else {
+    output.push(value);
+    counter--;
+   }
+  } else {
+   output.push(value);
+  }
+ }
+ return output;
+};
+var digitToBasic = function (digit) {
+ return digit + 22 + 75 * (digit < 26);
+};
+var adapt = function (delta, numPoints, firstTime) {
+ var k = 0;
+ delta = firstTime ? floor(delta / damp) : delta >> 1;
+ delta += floor(delta / numPoints);
+ for (; delta > baseMinusTMin * tMax >> 1; k += base) {
+  delta = floor(delta / baseMinusTMin);
+ }
+ return floor(k + (baseMinusTMin + 1) * delta / (delta + skew));
+};
+var encode = function (input) {
+ var output = [];
+ input = ucs2decode(input);
+ var inputLength = input.length;
+ var n = initialN;
+ var delta = 0;
+ var bias = initialBias;
+ var i, currentValue;
+ for (i = 0; i < input.length; i++) {
+  currentValue = input[i];
+  if (currentValue < 0x80) {
+   output.push(stringFromCharCode(currentValue));
+  }
+ }
+ var basicLength = output.length;
+ var handledCPCount = basicLength;
+ if (basicLength) {
+  output.push(delimiter);
+ }
+ while (handledCPCount < inputLength) {
+  var m = maxInt;
+  for (i = 0; i < input.length; i++) {
+   currentValue = input[i];
+   if (currentValue >= n && currentValue < m) {
+    m = currentValue;
+   }
+  }
+  var handledCPCountPlusOne = handledCPCount + 1;
+  if (m - n > floor((maxInt - delta) / handledCPCountPlusOne)) {
+   throw RangeError(OVERFLOW_ERROR);
+  }
+  delta += (m - n) * handledCPCountPlusOne;
+  n = m;
+  for (i = 0; i < input.length; i++) {
+   currentValue = input[i];
+   if (currentValue < n && ++delta > maxInt) {
+    throw RangeError(OVERFLOW_ERROR);
+   }
+   if (currentValue == n) {
+    var q = delta;
+    for (var k = base;; k += base) {
+     var t = k <= bias ? tMin : k >= bias + tMax ? tMax : k - bias;
+     if (q < t)
+      break;
+     var qMinusT = q - t;
+     var baseMinusT = base - t;
+     output.push(stringFromCharCode(digitToBasic(t + qMinusT % baseMinusT)));
+     q = floor(qMinusT / baseMinusT);
+    }
+    output.push(stringFromCharCode(digitToBasic(q)));
+    bias = adapt(delta, handledCPCountPlusOne, handledCPCount == basicLength);
+    delta = 0;
+    ++handledCPCount;
+   }
+  }
+  ++delta;
+  ++n;
+ }
+ return output.join('');
+};
+module.exports = function (input) {
+ var encoded = [];
+ var labels = input.toLowerCase().replace(regexSeparators, '\u002E').split('.');
+ var i, label;
+ for (i = 0; i < labels.length; i++) {
+  label = labels[i];
+  encoded.push(regexNonASCII.test(label) ? 'xn--' + encode(label) : label);
+ }
+ return encoded.join('.');
+};
+
+/***/ }),
+/* 140 */
+/***/ (function(module, exports, __w_pdfjs_require__) {
+
+"use strict";
+
+__w_pdfjs_require__(118);
+var $ = __w_pdfjs_require__(10);
+var getBuiltIn = __w_pdfjs_require__(42);
+var USE_NATIVE_URL = __w_pdfjs_require__(138);
+var redefine = __w_pdfjs_require__(29);
+var redefineAll = __w_pdfjs_require__(121);
+var setToStringTag = __w_pdfjs_require__(85);
+var createIteratorConstructor = __w_pdfjs_require__(80);
+var InternalStateModule = __w_pdfjs_require__(33);
+var anInstance = __w_pdfjs_require__(123);
+var hasOwn = __w_pdfjs_require__(23);
+var bind = __w_pdfjs_require__(62);
+var classof = __w_pdfjs_require__(95);
+var anObject = __w_pdfjs_require__(28);
+var isObject = __w_pdfjs_require__(22);
+var create = __w_pdfjs_require__(71);
+var createPropertyDescriptor = __w_pdfjs_require__(16);
+var getIterator = __w_pdfjs_require__(141);
+var getIteratorMethod = __w_pdfjs_require__(94);
+var wellKnownSymbol = __w_pdfjs_require__(57);
+var $fetch = getBuiltIn('fetch');
+var Headers = getBuiltIn('Headers');
+var ITERATOR = wellKnownSymbol('iterator');
+var URL_SEARCH_PARAMS = 'URLSearchParams';
+var URL_SEARCH_PARAMS_ITERATOR = URL_SEARCH_PARAMS + 'Iterator';
+var setInternalState = InternalStateModule.set;
+var getInternalParamsState = InternalStateModule.getterFor(URL_SEARCH_PARAMS);
+var getInternalIteratorState = InternalStateModule.getterFor(URL_SEARCH_PARAMS_ITERATOR);
+var plus = /\+/g;
+var sequences = Array(4);
+var percentSequence = function (bytes) {
+ return sequences[bytes - 1] || (sequences[bytes - 1] = RegExp('((?:%[\\da-f]{2}){' + bytes + '})', 'gi'));
+};
+var percentDecode = function (sequence) {
+ try {
+  return decodeURIComponent(sequence);
+ } catch (error) {
+  return sequence;
+ }
+};
+var deserialize = function (it) {
+ var result = it.replace(plus, ' ');
+ var bytes = 4;
+ try {
+  return decodeURIComponent(result);
+ } catch (error) {
+  while (bytes) {
+   result = result.replace(percentSequence(bytes--), percentDecode);
+  }
+  return result;
+ }
+};
+var find = /[!'()~]|%20/g;
+var replace = {
+ '!': '%21',
+ "'": '%27',
+ '(': '%28',
+ ')': '%29',
+ '~': '%7E',
+ '%20': '+'
+};
+var replacer = function (match) {
+ return replace[match];
+};
+var serialize = function (it) {
+ return encodeURIComponent(it).replace(find, replacer);
+};
+var parseSearchParams = function (result, query) {
+ if (query) {
+  var attributes = query.split('&');
+  var index = 0;
+  var attribute, entry;
+  while (index < attributes.length) {
+   attribute = attributes[index++];
+   if (attribute.length) {
+    entry = attribute.split('=');
+    result.push({
+     key: deserialize(entry.shift()),
+     value: deserialize(entry.join('='))
+    });
+   }
+  }
+ }
+};
+var updateSearchParams = function (query) {
+ this.entries.length = 0;
+ parseSearchParams(this.entries, query);
+};
+var validateArgumentsLength = function (passed, required) {
+ if (passed < required)
+  throw TypeError('Not enough arguments');
+};
+var URLSearchParamsIterator = createIteratorConstructor(function Iterator(params, kind) {
+ setInternalState(this, {
+  type: URL_SEARCH_PARAMS_ITERATOR,
+  iterator: getIterator(getInternalParamsState(params).entries),
+  kind: kind
+ });
+}, 'Iterator', function next() {
+ var state = getInternalIteratorState(this);
+ var kind = state.kind;
+ var step = state.iterator.next();
+ var entry = step.value;
+ if (!step.done) {
+  step.value = kind === 'keys' ? entry.key : kind === 'values' ? entry.value : [
+   entry.key,
+   entry.value
+  ];
+ }
+ return step;
+});
+var URLSearchParamsConstructor = function URLSearchParams() {
+ anInstance(this, URLSearchParamsConstructor, URL_SEARCH_PARAMS);
+ var init = arguments.length > 0 ? arguments[0] : undefined;
+ var that = this;
+ var entries = [];
+ var iteratorMethod, iterator, next, step, entryIterator, entryNext, first, second, key;
+ setInternalState(that, {
+  type: URL_SEARCH_PARAMS,
+  entries: entries,
+  updateURL: function () {
+  },
+  updateSearchParams: updateSearchParams
+ });
+ if (init !== undefined) {
+  if (isObject(init)) {
+   iteratorMethod = getIteratorMethod(init);
+   if (typeof iteratorMethod === 'function') {
+    iterator = iteratorMethod.call(init);
+    next = iterator.next;
+    while (!(step = next.call(iterator)).done) {
+     entryIterator = getIterator(anObject(step.value));
+     entryNext = entryIterator.next;
+     if ((first = entryNext.call(entryIterator)).done || (second = entryNext.call(entryIterator)).done || !entryNext.call(entryIterator).done)
+      throw TypeError('Expected sequence with length 2');
+     entries.push({
+      key: first.value + '',
+      value: second.value + ''
+     });
+    }
+   } else
+    for (key in init)
+     if (hasOwn(init, key))
+      entries.push({
+       key: key,
+       value: init[key] + ''
+      });
+  } else {
+   parseSearchParams(entries, typeof init === 'string' ? init.charAt(0) === '?' ? init.slice(1) : init : init + '');
+  }
+ }
+};
+var URLSearchParamsPrototype = URLSearchParamsConstructor.prototype;
+redefineAll(URLSearchParamsPrototype, {
+ append: function append(name, value) {
+  validateArgumentsLength(arguments.length, 2);
+  var state = getInternalParamsState(this);
+  state.entries.push({
+   key: name + '',
+   value: value + ''
+  });
+  state.updateURL();
+ },
+ 'delete': function (name) {
+  validateArgumentsLength(arguments.length, 1);
+  var state = getInternalParamsState(this);
+  var entries = state.entries;
+  var key = name + '';
+  var index = 0;
+  while (index < entries.length) {
+   if (entries[index].key === key)
+    entries.splice(index, 1);
+   else
+    index++;
+  }
+  state.updateURL();
+ },
+ get: function get(name) {
+  validateArgumentsLength(arguments.length, 1);
+  var entries = getInternalParamsState(this).entries;
+  var key = name + '';
+  var index = 0;
+  for (; index < entries.length; index++) {
+   if (entries[index].key === key)
+    return entries[index].value;
+  }
+  return null;
+ },
+ getAll: function getAll(name) {
+  validateArgumentsLength(arguments.length, 1);
+  var entries = getInternalParamsState(this).entries;
+  var key = name + '';
+  var result = [];
+  var index = 0;
+  for (; index < entries.length; index++) {
+   if (entries[index].key === key)
+    result.push(entries[index].value);
+  }
+  return result;
+ },
+ has: function has(name) {
+  validateArgumentsLength(arguments.length, 1);
+  var entries = getInternalParamsState(this).entries;
+  var key = name + '';
+  var index = 0;
+  while (index < entries.length) {
+   if (entries[index++].key === key)
+    return true;
+  }
+  return false;
+ },
+ set: function set(name, value) {
+  validateArgumentsLength(arguments.length, 1);
+  var state = getInternalParamsState(this);
+  var entries = state.entries;
+  var found = false;
+  var key = name + '';
+  var val = value + '';
+  var index = 0;
+  var entry;
+  for (; index < entries.length; index++) {
+   entry = entries[index];
+   if (entry.key === key) {
+    if (found)
+     entries.splice(index--, 1);
+    else {
+     found = true;
+     entry.value = val;
+    }
+   }
+  }
+  if (!found)
+   entries.push({
+    key: key,
+    value: val
+   });
+  state.updateURL();
+ },
+ sort: function sort() {
+  var state = getInternalParamsState(this);
+  var entries = state.entries;
+  var slice = entries.slice();
+  var entry, entriesIndex, sliceIndex;
+  entries.length = 0;
+  for (sliceIndex = 0; sliceIndex < slice.length; sliceIndex++) {
+   entry = slice[sliceIndex];
+   for (entriesIndex = 0; entriesIndex < sliceIndex; entriesIndex++) {
+    if (entries[entriesIndex].key > entry.key) {
+     entries.splice(entriesIndex, 0, entry);
+     break;
+    }
+   }
+   if (entriesIndex === sliceIndex)
+    entries.push(entry);
+  }
+  state.updateURL();
+ },
+ forEach: function forEach(callback) {
+  var entries = getInternalParamsState(this).entries;
+  var boundFunction = bind(callback, arguments.length > 1 ? arguments[1] : undefined, 3);
+  var index = 0;
+  var entry;
+  while (index < entries.length) {
+   entry = entries[index++];
+   boundFunction(entry.value, entry.key, this);
+  }
+ },
+ keys: function keys() {
+  return new URLSearchParamsIterator(this, 'keys');
+ },
+ values: function values() {
+  return new URLSearchParamsIterator(this, 'values');
+ },
+ entries: function entries() {
+  return new URLSearchParamsIterator(this, 'entries');
+ }
+}, { enumerable: true });
+redefine(URLSearchParamsPrototype, ITERATOR, URLSearchParamsPrototype.entries);
+redefine(URLSearchParamsPrototype, 'toString', function toString() {
+ var entries = getInternalParamsState(this).entries;
+ var result = [];
+ var index = 0;
+ var entry;
+ while (index < entries.length) {
+  entry = entries[index++];
+  result.push(serialize(entry.key) + '=' + serialize(entry.value));
+ }
+ return result.join('&');
+}, { enumerable: true });
+setToStringTag(URLSearchParamsConstructor, URL_SEARCH_PARAMS);
+$({
+ global: true,
+ forced: !USE_NATIVE_URL
+}, { URLSearchParams: URLSearchParamsConstructor });
+if (!USE_NATIVE_URL && typeof $fetch == 'function' && typeof Headers == 'function') {
+ $({
+  global: true,
+  enumerable: true,
+  forced: true
+ }, {
+  fetch: function fetch(input) {
+   var args = [input];
+   var init, body, headers;
+   if (arguments.length > 1) {
+    init = arguments[1];
+    if (isObject(init)) {
+     body = init.body;
+     if (classof(body) === URL_SEARCH_PARAMS) {
+      headers = init.headers ? new Headers(init.headers) : new Headers();
+      if (!headers.has('content-type')) {
+       headers.set('content-type', 'application/x-www-form-urlencoded;charset=UTF-8');
+      }
+      init = create(init, {
+       body: createPropertyDescriptor(0, String(body)),
+       headers: createPropertyDescriptor(0, headers)
+      });
+     }
+    }
+    args.push(init);
+   }
+   return $fetch.apply(this, args);
+  }
+ });
+}
+module.exports = {
+ URLSearchParams: URLSearchParamsConstructor,
+ getState: getInternalParamsState
+};
+
+/***/ }),
+/* 141 */
+/***/ (function(module, exports, __w_pdfjs_require__) {
+
+var anObject = __w_pdfjs_require__(28);
+var getIteratorMethod = __w_pdfjs_require__(94);
+module.exports = function (it) {
+ var iteratorMethod = getIteratorMethod(it);
+ if (typeof iteratorMethod != 'function') {
+  throw TypeError(String(it) + ' is not iterable');
+ }
+ return anObject(iteratorMethod.call(it));
+};
+
+/***/ }),
+/* 142 */
+/***/ (function(module, exports, __w_pdfjs_require__) {
+
+"use strict";
+
+var $ = __w_pdfjs_require__(10);
+$({
+ target: 'URL',
+ proto: true,
+ enumerable: true
+}, {
+ toJSON: function toJSON() {
+  return URL.prototype.toString.call(this);
+ }
+});
+
+/***/ }),
+/* 143 */
+/***/ (function(module, exports, __w_pdfjs_require__) {
+
+(function (global, factory) {
+  true ? factory(exports) : undefined;
+}(this, function (exports) {
+ 'use strict';
+ var SymbolPolyfill = typeof Symbol === 'function' && typeof Symbol.iterator === 'symbol' ? Symbol : function (description) {
+  return "Symbol(" + description + ")";
+ };
+ function noop() {
+ }
+ var NumberIsNaN = Number.isNaN || function (x) {
+  return x !== x;
+ };
+ var rethrowAssertionErrorRejection = noop;
+ function typeIsObject(x) {
+  return typeof x === 'object' && x !== null || typeof x === 'function';
+ }
+ function createArrayFromList(elements) {
+  return elements.slice();
+ }
+ function ArrayBufferCopy(dest, destOffset, src, srcOffset, n) {
+  new Uint8Array(dest).set(new Uint8Array(src, srcOffset, n), destOffset);
+ }
+ function IsFiniteNonNegativeNumber(v) {
+  if (IsNonNegativeNumber(v) === false) {
+   return false;
+  }
+  if (v === Infinity) {
+   return false;
+  }
+  return true;
+ }
+ function IsNonNegativeNumber(v) {
+  if (typeof v !== 'number') {
+   return false;
+  }
+  if (NumberIsNaN(v)) {
+   return false;
+  }
+  if (v < 0) {
+   return false;
+  }
+  return true;
+ }
+ function Call(F, V, args) {
+  if (typeof F !== 'function') {
+   throw new TypeError('Argument is not a function');
+  }
+  return Function.prototype.apply.call(F, V, args);
+ }
+ function CreateAlgorithmFromUnderlyingMethod(underlyingObject, methodName, algoArgCount, extraArgs) {
+  var method = underlyingObject[methodName];
+  if (method !== undefined) {
+   if (typeof method !== 'function') {
+    throw new TypeError(method + " is not a method");
+   }
+   switch (algoArgCount) {
+   case 0: {
+     return function () {
+      return PromiseCall(method, underlyingObject, extraArgs);
+     };
+    }
+   case 1: {
+     return function (arg) {
+      var fullArgs = [arg].concat(extraArgs);
+      return PromiseCall(method, underlyingObject, fullArgs);
+     };
+    }
+   }
+  }
+  return function () {
+   return promiseResolvedWith(undefined);
+  };
+ }
+ function InvokeOrNoop(O, P, args) {
+  var method = O[P];
+  if (method === undefined) {
+   return undefined;
+  }
+  return Call(method, O, args);
+ }
+ function PromiseCall(F, V, args) {
+  try {
+   return promiseResolvedWith(Call(F, V, args));
+  } catch (value) {
+   return promiseRejectedWith(value);
+  }
+ }
+ function TransferArrayBuffer(O) {
+  return O;
+ }
+ function IsDetachedBuffer(O) {
+  return false;
+ }
+ function ValidateAndNormalizeHighWaterMark(highWaterMark) {
+  highWaterMark = Number(highWaterMark);
+  if (NumberIsNaN(highWaterMark) || highWaterMark < 0) {
+   throw new RangeError('highWaterMark property of a queuing strategy must be non-negative and non-NaN');
+  }
+  return highWaterMark;
+ }
+ function MakeSizeAlgorithmFromSizeFunction(size) {
+  if (size === undefined) {
+   return function () {
+    return 1;
+   };
+  }
+  if (typeof size !== 'function') {
+   throw new TypeError('size property of a queuing strategy must be a function');
+  }
+  return function (chunk) {
+   return size(chunk);
+  };
+ }
+ var originalPromise = Promise;
+ var originalPromiseThen = Promise.prototype.then;
+ var originalPromiseResolve = Promise.resolve.bind(originalPromise);
+ var originalPromiseReject = Promise.reject.bind(originalPromise);
+ function newPromise(executor) {
+  return new originalPromise(executor);
+ }
+ function promiseResolvedWith(value) {
+  return originalPromiseResolve(value);
+ }
+ function promiseRejectedWith(reason) {
+  return originalPromiseReject(reason);
+ }
+ function PerformPromiseThen(promise, onFulfilled, onRejected) {
+  return originalPromiseThen.call(promise, onFulfilled, onRejected);
+ }
+ function uponPromise(promise, onFulfilled, onRejected) {
+  PerformPromiseThen(PerformPromiseThen(promise, onFulfilled, onRejected), undefined, rethrowAssertionErrorRejection);
+ }
+ function uponFulfillment(promise, onFulfilled) {
+  uponPromise(promise, onFulfilled);
+ }
+ function uponRejection(promise, onRejected) {
+  uponPromise(promise, undefined, onRejected);
+ }
+ function transformPromiseWith(promise, fulfillmentHandler, rejectionHandler) {
+  return PerformPromiseThen(promise, fulfillmentHandler, rejectionHandler);
+ }
+ function setPromiseIsHandledToTrue(promise) {
+  PerformPromiseThen(promise, undefined, rethrowAssertionErrorRejection);
+ }
+ var QUEUE_MAX_ARRAY_SIZE = 16384;
+ var SimpleQueue = function () {
+  function SimpleQueue() {
+   this._cursor = 0;
+   this._size = 0;
+   this._front = {
+    _elements: [],
+    _next: undefined
+   };
+   this._back = this._front;
+   this._cursor = 0;
+   this._size = 0;
+  }
+  Object.defineProperty(SimpleQueue.prototype, "length", {
+   get: function () {
+    return this._size;
+   },
+   enumerable: true,
+   configurable: true
+  });
+  SimpleQueue.prototype.push = function (element) {
+   var oldBack = this._back;
+   var newBack = oldBack;
+   if (oldBack._elements.length === QUEUE_MAX_ARRAY_SIZE - 1) {
+    newBack = {
+     _elements: [],
+     _next: undefined
+    };
+   }
+   oldBack._elements.push(element);
+   if (newBack !== oldBack) {
+    this._back = newBack;
+    oldBack._next = newBack;
+   }
+   ++this._size;
+  };
+  SimpleQueue.prototype.shift = function () {
+   var oldFront = this._front;
+   var newFront = oldFront;
+   var oldCursor = this._cursor;
+   var newCursor = oldCursor + 1;
+   var elements = oldFront._elements;
+   var element = elements[oldCursor];
+   if (newCursor === QUEUE_MAX_ARRAY_SIZE) {
+    newFront = oldFront._next;
+    newCursor = 0;
+   }
+   --this._size;
+   this._cursor = newCursor;
+   if (oldFront !== newFront) {
+    this._front = newFront;
+   }
+   elements[oldCursor] = undefined;
+   return element;
+  };
+  SimpleQueue.prototype.forEach = function (callback) {
+   var i = this._cursor;
+   var node = this._front;
+   var elements = node._elements;
+   while (i !== elements.length || node._next !== undefined) {
+    if (i === elements.length) {
+     node = node._next;
+     elements = node._elements;
+     i = 0;
+     if (elements.length === 0) {
+      break;
+     }
+    }
+    callback(elements[i]);
+    ++i;
+   }
+  };
+  SimpleQueue.prototype.peek = function () {
+   var front = this._front;
+   var cursor = this._cursor;
+   return front._elements[cursor];
+  };
+  return SimpleQueue;
+ }();
+ function ReadableStreamCreateReadResult(value, done, forAuthorCode) {
+  var prototype = null;
+  if (forAuthorCode === true) {
+   prototype = Object.prototype;
+  }
+  var obj = Object.create(prototype);
+  obj.value = value;
+  obj.done = done;
+  return obj;
+ }
+ function ReadableStreamReaderGenericInitialize(reader, stream) {
+  reader._forAuthorCode = true;
+  reader._ownerReadableStream = stream;
+  stream._reader = reader;
+  if (stream._state === 'readable') {
+   defaultReaderClosedPromiseInitialize(reader);
+  } else if (stream._state === 'closed') {
+   defaultReaderClosedPromiseInitializeAsResolved(reader);
+  } else {
+   defaultReaderClosedPromiseInitializeAsRejected(reader, stream._storedError);
+  }
+ }
+ function ReadableStreamReaderGenericCancel(reader, reason) {
+  var stream = reader._ownerReadableStream;
+  return ReadableStreamCancel(stream, reason);
+ }
+ function ReadableStreamReaderGenericRelease(reader) {
+  if (reader._ownerReadableStream._state === 'readable') {
+   defaultReaderClosedPromiseReject(reader, new TypeError('Reader was released and can no longer be used to monitor the stream\'s closedness'));
+  } else {
+   defaultReaderClosedPromiseResetToRejected(reader, new TypeError('Reader was released and can no longer be used to monitor the stream\'s closedness'));
+  }
+  reader._ownerReadableStream._reader = undefined;
+  reader._ownerReadableStream = undefined;
+ }
+ function readerLockException(name) {
+  return new TypeError('Cannot ' + name + ' a stream using a released reader');
+ }
+ function defaultReaderClosedPromiseInitialize(reader) {
+  reader._closedPromise = newPromise(function (resolve, reject) {
+   reader._closedPromise_resolve = resolve;
+   reader._closedPromise_reject = reject;
+  });
+ }
+ function defaultReaderClosedPromiseInitializeAsRejected(reader, reason) {
+  defaultReaderClosedPromiseInitialize(reader);
+  defaultReaderClosedPromiseReject(reader, reason);
+ }
+ function defaultReaderClosedPromiseInitializeAsResolved(reader) {
+  defaultReaderClosedPromiseInitialize(reader);
+  defaultReaderClosedPromiseResolve(reader);
+ }
+ function defaultReaderClosedPromiseReject(reader, reason) {
+  setPromiseIsHandledToTrue(reader._closedPromise);
+  reader._closedPromise_reject(reason);
+  reader._closedPromise_resolve = undefined;
+  reader._closedPromise_reject = undefined;
+ }
+ function defaultReaderClosedPromiseResetToRejected(reader, reason) {
+  defaultReaderClosedPromiseInitializeAsRejected(reader, reason);
+ }
+ function defaultReaderClosedPromiseResolve(reader) {
+  reader._closedPromise_resolve(undefined);
+  reader._closedPromise_resolve = undefined;
+  reader._closedPromise_reject = undefined;
+ }
+ var CancelSteps = SymbolPolyfill('[[CancelSteps]]');
+ var PullSteps = SymbolPolyfill('[[PullSteps]]');
+ function AcquireReadableStreamDefaultReader(stream, forAuthorCode) {
+  if (forAuthorCode === void 0) {
+   forAuthorCode = false;
+  }
+  var reader = new ReadableStreamDefaultReader(stream);
+  reader._forAuthorCode = forAuthorCode;
+  return reader;
+ }
+ function ReadableStreamAddReadRequest(stream) {
+  var promise = newPromise(function (resolve, reject) {
+   var readRequest = {
+    _resolve: resolve,
+    _reject: reject
+   };
+   stream._reader._readRequests.push(readRequest);
+  });
+  return promise;
+ }
+ function ReadableStreamFulfillReadRequest(stream, chunk, done) {
+  var reader = stream._reader;
+  var readRequest = reader._readRequests.shift();
+  readRequest._resolve(ReadableStreamCreateReadResult(chunk, done, reader._forAuthorCode));
+ }
+ function ReadableStreamGetNumReadRequests(stream) {
+  return stream._reader._readRequests.length;
+ }
+ function ReadableStreamHasDefaultReader(stream) {
+  var reader = stream._reader;
+  if (reader === undefined) {
+   return false;
+  }
+  if (!IsReadableStreamDefaultReader(reader)) {
+   return false;
+  }
+  return true;
+ }
+ var ReadableStreamDefaultReader = function () {
+  function ReadableStreamDefaultReader(stream) {
+   if (IsReadableStream(stream) === false) {
+    throw new TypeError('ReadableStreamDefaultReader can only be constructed with a ReadableStream instance');
+   }
+   if (IsReadableStreamLocked(stream) === true) {
+    throw new TypeError('This stream has already been locked for exclusive reading by another reader');
+   }
+   ReadableStreamReaderGenericInitialize(this, stream);
+   this._readRequests = new SimpleQueue();
+  }
+  Object.defineProperty(ReadableStreamDefaultReader.prototype, "closed", {
+   get: function () {
+    if (!IsReadableStreamDefaultReader(this)) {
+     return promiseRejectedWith(defaultReaderBrandCheckException('closed'));
+    }
+    return this._closedPromise;
+   },
+   enumerable: true,
+   configurable: true
+  });
+  ReadableStreamDefaultReader.prototype.cancel = function (reason) {
+   if (!IsReadableStreamDefaultReader(this)) {
+    return promiseRejectedWith(defaultReaderBrandCheckException('cancel'));
+   }
+   if (this._ownerReadableStream === undefined) {
+    return promiseRejectedWith(readerLockException('cancel'));
+   }
+   return ReadableStreamReaderGenericCancel(this, reason);
+  };
+  ReadableStreamDefaultReader.prototype.read = function () {
+   if (!IsReadableStreamDefaultReader(this)) {
+    return promiseRejectedWith(defaultReaderBrandCheckException('read'));
+   }
+   if (this._ownerReadableStream === undefined) {
+    return promiseRejectedWith(readerLockException('read from'));
+   }
+   return ReadableStreamDefaultReaderRead(this);
+  };
+  ReadableStreamDefaultReader.prototype.releaseLock = function () {
+   if (!IsReadableStreamDefaultReader(this)) {
+    throw defaultReaderBrandCheckException('releaseLock');
+   }
+   if (this._ownerReadableStream === undefined) {
+    return;
+   }
+   if (this._readRequests.length > 0) {
+    throw new TypeError('Tried to release a reader lock when that reader has pending read() calls un-settled');
+   }
+   ReadableStreamReaderGenericRelease(this);
+  };
+  return ReadableStreamDefaultReader;
+ }();
+ function IsReadableStreamDefaultReader(x) {
+  if (!typeIsObject(x)) {
+   return false;
+  }
+  if (!Object.prototype.hasOwnProperty.call(x, '_readRequests')) {
+   return false;
+  }
+  return true;
+ }
+ function ReadableStreamDefaultReaderRead(reader) {
+  var stream = reader._ownerReadableStream;
+  stream._disturbed = true;
+  if (stream._state === 'closed') {
+   return promiseResolvedWith(ReadableStreamCreateReadResult(undefined, true, reader._forAuthorCode));
+  }
+  if (stream._state === 'errored') {
+   return promiseRejectedWith(stream._storedError);
+  }
+  return stream._readableStreamController[PullSteps]();
+ }
+ function defaultReaderBrandCheckException(name) {
+  return new TypeError("ReadableStreamDefaultReader.prototype." + name + " can only be used on a ReadableStreamDefaultReader");
+ }
+ var _a;
+ var AsyncIteratorPrototype;
+ if (typeof SymbolPolyfill.asyncIterator === 'symbol') {
+  AsyncIteratorPrototype = (_a = {}, _a[SymbolPolyfill.asyncIterator] = function () {
+   return this;
+  }, _a);
+  Object.defineProperty(AsyncIteratorPrototype, SymbolPolyfill.asyncIterator, { enumerable: false });
+ }
+ var ReadableStreamAsyncIteratorPrototype = {
+  next: function () {
+   if (IsReadableStreamAsyncIterator(this) === false) {
+    return promiseRejectedWith(streamAsyncIteratorBrandCheckException('next'));
+   }
+   var reader = this._asyncIteratorReader;
+   if (reader._ownerReadableStream === undefined) {
+    return promiseRejectedWith(readerLockException('iterate'));
+   }
+   return transformPromiseWith(ReadableStreamDefaultReaderRead(reader), function (result) {
+    var done = result.done;
+    if (done) {
+     ReadableStreamReaderGenericRelease(reader);
+    }
+    var value = result.value;
+    return ReadableStreamCreateReadResult(value, done, true);
+   });
+  },
+  return: function (value) {
+   if (IsReadableStreamAsyncIterator(this) === false) {
+    return promiseRejectedWith(streamAsyncIteratorBrandCheckException('next'));
+   }
+   var reader = this._asyncIteratorReader;
+   if (reader._ownerReadableStream === undefined) {
+    return promiseRejectedWith(readerLockException('finish iterating'));
+   }
+   if (reader._readRequests.length > 0) {
+    return promiseRejectedWith(new TypeError('Tried to release a reader lock when that reader has pending read() calls un-settled'));
+   }
+   if (this._preventCancel === false) {
+    var result = ReadableStreamReaderGenericCancel(reader, value);
+    ReadableStreamReaderGenericRelease(reader);
+    return transformPromiseWith(result, function () {
+     return ReadableStreamCreateReadResult(value, true, true);
+    });
+   }
+   ReadableStreamReaderGenericRelease(reader);
+   return promiseResolvedWith(ReadableStreamCreateReadResult(value, true, true));
+  }
+ };
+ if (AsyncIteratorPrototype !== undefined) {
+  Object.setPrototypeOf(ReadableStreamAsyncIteratorPrototype, AsyncIteratorPrototype);
+ }
+ Object.defineProperty(ReadableStreamAsyncIteratorPrototype, 'next', { enumerable: false });
+ Object.defineProperty(ReadableStreamAsyncIteratorPrototype, 'return', { enumerable: false });
+ function AcquireReadableStreamAsyncIterator(stream, preventCancel) {
+  if (preventCancel === void 0) {
+   preventCancel = false;
+  }
+  var reader = AcquireReadableStreamDefaultReader(stream);
+  var iterator = Object.create(ReadableStreamAsyncIteratorPrototype);
+  iterator._asyncIteratorReader = reader;
+  iterator._preventCancel = Boolean(preventCancel);
+  return iterator;
+ }
+ function IsReadableStreamAsyncIterator(x) {
+  if (!typeIsObject(x)) {
+   return false;
+  }
+  if (!Object.prototype.hasOwnProperty.call(x, '_asyncIteratorReader')) {
+   return false;
+  }
+  return true;
+ }
+ function streamAsyncIteratorBrandCheckException(name) {
+  return new TypeError("ReadableStreamAsyncIterator." + name + " can only be used on a ReadableSteamAsyncIterator");
+ }
+ function DequeueValue(container) {
+  var pair = container._queue.shift();
+  container._queueTotalSize -= pair.size;
+  if (container._queueTotalSize < 0) {
+   container._queueTotalSize = 0;
+  }
+  return pair.value;
+ }
+ function EnqueueValueWithSize(container, value, size) {
+  size = Number(size);
+  if (!IsFiniteNonNegativeNumber(size)) {
+   throw new RangeError('Size must be a finite, non-NaN, non-negative number.');
+  }
+  container._queue.push({
+   value: value,
+   size: size
+  });
+  container._queueTotalSize += size;
+ }
+ function PeekQueueValue(container) {
+  var pair = container._queue.peek();
+  return pair.value;
+ }
+ function ResetQueue(container) {
+  container._queue = new SimpleQueue();
+  container._queueTotalSize = 0;
+ }
+ var AbortSteps = SymbolPolyfill('[[AbortSteps]]');
+ var ErrorSteps = SymbolPolyfill('[[ErrorSteps]]');
+ var WritableStream = function () {
+  function WritableStream(underlyingSink, strategy) {
+   if (underlyingSink === void 0) {
+    underlyingSink = {};
+   }
+   if (strategy === void 0) {
+    strategy = {};
+   }
+   InitializeWritableStream(this);
+   var size = strategy.size;
+   var highWaterMark = strategy.highWaterMark;
+   var type = underlyingSink.type;
+   if (type !== undefined) {
+    throw new RangeError('Invalid type is specified');
+   }
+   var sizeAlgorithm = MakeSizeAlgorithmFromSizeFunction(size);
+   if (highWaterMark === undefined) {
+    highWaterMark = 1;
+   }
+   highWaterMark = ValidateAndNormalizeHighWaterMark(highWaterMark);
+   SetUpWritableStreamDefaultControllerFromUnderlyingSink(this, underlyingSink, highWaterMark, sizeAlgorithm);
+  }
+  Object.defineProperty(WritableStream.prototype, "locked", {
+   get: function () {
+    if (IsWritableStream(this) === false) {
+     throw streamBrandCheckException('locked');
+    }
+    return IsWritableStreamLocked(this);
+   },
+   enumerable: true,
+   configurable: true
+  });
+  WritableStream.prototype.abort = function (reason) {
+   if (IsWritableStream(this) === false) {
+    return promiseRejectedWith(streamBrandCheckException('abort'));
+   }
+   if (IsWritableStreamLocked(this) === true) {
+    return promiseRejectedWith(new TypeError('Cannot abort a stream that already has a writer'));
+   }
+   return WritableStreamAbort(this, reason);
+  };
+  WritableStream.prototype.close = function () {
+   if (IsWritableStream(this) === false) {
+    return promiseRejectedWith(streamBrandCheckException('close'));
+   }
+   if (IsWritableStreamLocked(this) === true) {
+    return promiseRejectedWith(new TypeError('Cannot close a stream that already has a writer'));
+   }
+   if (WritableStreamCloseQueuedOrInFlight(this) === true) {
+    return promiseRejectedWith(new TypeError('Cannot close an already-closing stream'));
+   }
+   return WritableStreamClose(this);
+  };
+  WritableStream.prototype.getWriter = function () {
+   if (IsWritableStream(this) === false) {
+    throw streamBrandCheckException('getWriter');
+   }
+   return AcquireWritableStreamDefaultWriter(this);
+  };
+  return WritableStream;
+ }();
+ function AcquireWritableStreamDefaultWriter(stream) {
+  return new WritableStreamDefaultWriter(stream);
+ }
+ function CreateWritableStream(startAlgorithm, writeAlgorithm, closeAlgorithm, abortAlgorithm, highWaterMark, sizeAlgorithm) {
+  if (highWaterMark === void 0) {
+   highWaterMark = 1;
+  }
+  if (sizeAlgorithm === void 0) {
+   sizeAlgorithm = function () {
+    return 1;
+   };
+  }
+  var stream = Object.create(WritableStream.prototype);
+  InitializeWritableStream(stream);
+  var controller = Object.create(WritableStreamDefaultController.prototype);
+  SetUpWritableStreamDefaultController(stream, controller, startAlgorithm, writeAlgorithm, closeAlgorithm, abortAlgorithm, highWaterMark, sizeAlgorithm);
+  return stream;
+ }
+ function InitializeWritableStream(stream) {
+  stream._state = 'writable';
+  stream._storedError = undefined;
+  stream._writer = undefined;
+  stream._writableStreamController = undefined;
+  stream._writeRequests = new SimpleQueue();
+  stream._inFlightWriteRequest = undefined;
+  stream._closeRequest = undefined;
+  stream._inFlightCloseRequest = undefined;
+  stream._pendingAbortRequest = undefined;
+  stream._backpressure = false;
+ }
+ function IsWritableStream(x) {
+  if (!typeIsObject(x)) {
+   return false;
+  }
+  if (!Object.prototype.hasOwnProperty.call(x, '_writableStreamController')) {
+   return false;
+  }
+  return true;
+ }
+ function IsWritableStreamLocked(stream) {
+  if (stream._writer === undefined) {
+   return false;
+  }
+  return true;
+ }
+ function WritableStreamAbort(stream, reason) {
+  var state = stream._state;
+  if (state === 'closed' || state === 'errored') {
+   return promiseResolvedWith(undefined);
+  }
+  if (stream._pendingAbortRequest !== undefined) {
+   return stream._pendingAbortRequest._promise;
+  }
+  var wasAlreadyErroring = false;
+  if (state === 'erroring') {
+   wasAlreadyErroring = true;
+   reason = undefined;
+  }
+  var promise = newPromise(function (resolve, reject) {
+   stream._pendingAbortRequest = {
+    _promise: undefined,
+    _resolve: resolve,
+    _reject: reject,
+    _reason: reason,
+    _wasAlreadyErroring: wasAlreadyErroring
+   };
+  });
+  stream._pendingAbortRequest._promise = promise;
+  if (wasAlreadyErroring === false) {
+   WritableStreamStartErroring(stream, reason);
+  }
+  return promise;
+ }
+ function WritableStreamClose(stream) {
+  var state = stream._state;
+  if (state === 'closed' || state === 'errored') {
+   return promiseRejectedWith(new TypeError("The stream (in " + state + " state) is not in the writable state and cannot be closed"));
+  }
+  var promise = newPromise(function (resolve, reject) {
+   var closeRequest = {
+    _resolve: resolve,
+    _reject: reject
+   };
+   stream._closeRequest = closeRequest;
+  });
+  var writer = stream._writer;
+  if (writer !== undefined && stream._backpressure === true && state === 'writable') {
+   defaultWriterReadyPromiseResolve(writer);
+  }
+  WritableStreamDefaultControllerClose(stream._writableStreamController);
+  return promise;
+ }
+ function WritableStreamAddWriteRequest(stream) {
+  var promise = newPromise(function (resolve, reject) {
+   var writeRequest = {
+    _resolve: resolve,
+    _reject: reject
+   };
+   stream._writeRequests.push(writeRequest);
+  });
+  return promise;
+ }
+ function WritableStreamDealWithRejection(stream, error) {
+  var state = stream._state;
+  if (state === 'writable') {
+   WritableStreamStartErroring(stream, error);
+   return;
+  }
+  WritableStreamFinishErroring(stream);
+ }
+ function WritableStreamStartErroring(stream, reason) {
+  var controller = stream._writableStreamController;
+  stream._state = 'erroring';
+  stream._storedError = reason;
+  var writer = stream._writer;
+  if (writer !== undefined) {
+   WritableStreamDefaultWriterEnsureReadyPromiseRejected(writer, reason);
+  }
+  if (WritableStreamHasOperationMarkedInFlight(stream) === false && controller._started === true) {
+   WritableStreamFinishErroring(stream);
+  }
+ }
+ function WritableStreamFinishErroring(stream) {
+  stream._state = 'errored';
+  stream._writableStreamController[ErrorSteps]();
+  var storedError = stream._storedError;
+  stream._writeRequests.forEach(function (writeRequest) {
+   writeRequest._reject(storedError);
+  });
+  stream._writeRequests = new SimpleQueue();
+  if (stream._pendingAbortRequest === undefined) {
+   WritableStreamRejectCloseAndClosedPromiseIfNeeded(stream);
+   return;
+  }
+  var abortRequest = stream._pendingAbortRequest;
+  stream._pendingAbortRequest = undefined;
+  if (abortRequest._wasAlreadyErroring === true) {
+   abortRequest._reject(storedError);
+   WritableStreamRejectCloseAndClosedPromiseIfNeeded(stream);
+   return;
+  }
+  var promise = stream._writableStreamController[AbortSteps](abortRequest._reason);
+  uponPromise(promise, function () {
+   abortRequest._resolve();
+   WritableStreamRejectCloseAndClosedPromiseIfNeeded(stream);
+  }, function (reason) {
+   abortRequest._reject(reason);
+   WritableStreamRejectCloseAndClosedPromiseIfNeeded(stream);
+  });
+ }
+ function WritableStreamFinishInFlightWrite(stream) {
+  stream._inFlightWriteRequest._resolve(undefined);
+  stream._inFlightWriteRequest = undefined;
+ }
+ function WritableStreamFinishInFlightWriteWithError(stream, error) {
+  stream._inFlightWriteRequest._reject(error);
+  stream._inFlightWriteRequest = undefined;
+  WritableStreamDealWithRejection(stream, error);
+ }
+ function WritableStreamFinishInFlightClose(stream) {
+  stream._inFlightCloseRequest._resolve(undefined);
+  stream._inFlightCloseRequest = undefined;
+  var state = stream._state;
+  if (state === 'erroring') {
+   stream._storedError = undefined;
+   if (stream._pendingAbortRequest !== undefined) {
+    stream._pendingAbortRequest._resolve();
+    stream._pendingAbortRequest = undefined;
+   }
+  }
+  stream._state = 'closed';
+  var writer = stream._writer;
+  if (writer !== undefined) {
+   defaultWriterClosedPromiseResolve(writer);
+  }
+ }
+ function WritableStreamFinishInFlightCloseWithError(stream, error) {
+  stream._inFlightCloseRequest._reject(error);
+  stream._inFlightCloseRequest = undefined;
+  if (stream._pendingAbortRequest !== undefined) {
+   stream._pendingAbortRequest._reject(error);
+   stream._pendingAbortRequest = undefined;
+  }
+  WritableStreamDealWithRejection(stream, error);
+ }
+ function WritableStreamCloseQueuedOrInFlight(stream) {
+  if (stream._closeRequest === undefined && stream._inFlightCloseRequest === undefined) {
+   return false;
+  }
+  return true;
+ }
+ function WritableStreamHasOperationMarkedInFlight(stream) {
+  if (stream._inFlightWriteRequest === undefined && stream._inFlightCloseRequest === undefined) {
+   return false;
+  }
+  return true;
+ }
+ function WritableStreamMarkCloseRequestInFlight(stream) {
+  stream._inFlightCloseRequest = stream._closeRequest;
+  stream._closeRequest = undefined;
+ }
+ function WritableStreamMarkFirstWriteRequestInFlight(stream) {
+  stream._inFlightWriteRequest = stream._writeRequests.shift();
+ }
+ function WritableStreamRejectCloseAndClosedPromiseIfNeeded(stream) {
+  if (stream._closeRequest !== undefined) {
+   stream._closeRequest._reject(stream._storedError);
+   stream._closeRequest = undefined;
+  }
+  var writer = stream._writer;
+  if (writer !== undefined) {
+   defaultWriterClosedPromiseReject(writer, stream._storedError);
+  }
+ }
+ function WritableStreamUpdateBackpressure(stream, backpressure) {
+  var writer = stream._writer;
+  if (writer !== undefined && backpressure !== stream._backpressure) {
+   if (backpressure === true) {
+    defaultWriterReadyPromiseReset(writer);
+   } else {
+    defaultWriterReadyPromiseResolve(writer);
+   }
+  }
+  stream._backpressure = backpressure;
+ }
+ var WritableStreamDefaultWriter = function () {
+  function WritableStreamDefaultWriter(stream) {
+   if (IsWritableStream(stream) === false) {
+    throw new TypeError('WritableStreamDefaultWriter can only be constructed with a WritableStream instance');
+   }
+   if (IsWritableStreamLocked(stream) === true) {
+    throw new TypeError('This stream has already been locked for exclusive writing by another writer');
+   }
+   this._ownerWritableStream = stream;
+   stream._writer = this;
+   var state = stream._state;
+   if (state === 'writable') {
+    if (WritableStreamCloseQueuedOrInFlight(stream) === false && stream._backpressure === true) {
+     defaultWriterReadyPromiseInitialize(this);
+    } else {
+     defaultWriterReadyPromiseInitializeAsResolved(this);
+    }
+    defaultWriterClosedPromiseInitialize(this);
+   } else if (state === 'erroring') {
+    defaultWriterReadyPromiseInitializeAsRejected(this, stream._storedError);
+    defaultWriterClosedPromiseInitialize(this);
+   } else if (state === 'closed') {
+    defaultWriterReadyPromiseInitializeAsResolved(this);
+    defaultWriterClosedPromiseInitializeAsResolved(this);
+   } else {
+    var storedError = stream._storedError;
+    defaultWriterReadyPromiseInitializeAsRejected(this, storedError);
+    defaultWriterClosedPromiseInitializeAsRejected(this, storedError);
+   }
+  }
+  Object.defineProperty(WritableStreamDefaultWriter.prototype, "closed", {
+   get: function () {
+    if (IsWritableStreamDefaultWriter(this) === false) {
+     return promiseRejectedWith(defaultWriterBrandCheckException('closed'));
+    }
+    return this._closedPromise;
+   },
+   enumerable: true,
+   configurable: true
+  });
+  Object.defineProperty(WritableStreamDefaultWriter.prototype, "desiredSize", {
+   get: function () {
+    if (IsWritableStreamDefaultWriter(this) === false) {
+     throw defaultWriterBrandCheckException('desiredSize');
+    }
+    if (this._ownerWritableStream === undefined) {
+     throw defaultWriterLockException('desiredSize');
+    }
+    return WritableStreamDefaultWriterGetDesiredSize(this);
+   },
+   enumerable: true,
+   configurable: true
+  });
+  Object.defineProperty(WritableStreamDefaultWriter.prototype, "ready", {
+   get: function () {
+    if (IsWritableStreamDefaultWriter(this) === false) {
+     return promiseRejectedWith(defaultWriterBrandCheckException('ready'));
+    }
+    return this._readyPromise;
+   },
+   enumerable: true,
+   configurable: true
+  });
+  WritableStreamDefaultWriter.prototype.abort = function (reason) {
+   if (IsWritableStreamDefaultWriter(this) === false) {
+    return promiseRejectedWith(defaultWriterBrandCheckException('abort'));
+   }
+   if (this._ownerWritableStream === undefined) {
+    return promiseRejectedWith(defaultWriterLockException('abort'));
+   }
+   return WritableStreamDefaultWriterAbort(this, reason);
+  };
+  WritableStreamDefaultWriter.prototype.close = function () {
+   if (IsWritableStreamDefaultWriter(this) === false) {
+    return promiseRejectedWith(defaultWriterBrandCheckException('close'));
+   }
+   var stream = this._ownerWritableStream;
+   if (stream === undefined) {
+    return promiseRejectedWith(defaultWriterLockException('close'));
+   }
+   if (WritableStreamCloseQueuedOrInFlight(stream) === true) {
+    return promiseRejectedWith(new TypeError('Cannot close an already-closing stream'));
+   }
+   return WritableStreamDefaultWriterClose(this);
+  };
+  WritableStreamDefaultWriter.prototype.releaseLock = function () {
+   if (IsWritableStreamDefaultWriter(this) === false) {
+    throw defaultWriterBrandCheckException('releaseLock');
+   }
+   var stream = this._ownerWritableStream;
+   if (stream === undefined) {
+    return;
+   }
+   WritableStreamDefaultWriterRelease(this);
+  };
+  WritableStreamDefaultWriter.prototype.write = function (chunk) {
+   if (IsWritableStreamDefaultWriter(this) === false) {
+    return promiseRejectedWith(defaultWriterBrandCheckException('write'));
+   }
+   if (this._ownerWritableStream === undefined) {
+    return promiseRejectedWith(defaultWriterLockException('write to'));
+   }
+   return WritableStreamDefaultWriterWrite(this, chunk);
+  };
+  return WritableStreamDefaultWriter;
+ }();
+ function IsWritableStreamDefaultWriter(x) {
+  if (!typeIsObject(x)) {
+   return false;
+  }
+  if (!Object.prototype.hasOwnProperty.call(x, '_ownerWritableStream')) {
+   return false;
+  }
+  return true;
+ }
+ function WritableStreamDefaultWriterAbort(writer, reason) {
+  var stream = writer._ownerWritableStream;
+  return WritableStreamAbort(stream, reason);
+ }
+ function WritableStreamDefaultWriterClose(writer) {
+  var stream = writer._ownerWritableStream;
+  return WritableStreamClose(stream);
+ }
+ function WritableStreamDefaultWriterCloseWithErrorPropagation(writer) {
+  var stream = writer._ownerWritableStream;
+  var state = stream._state;
+  if (WritableStreamCloseQueuedOrInFlight(stream) === true || state === 'closed') {
+   return promiseResolvedWith(undefined);
+  }
+  if (state === 'errored') {
+   return promiseRejectedWith(stream._storedError);
+  }
+  return WritableStreamDefaultWriterClose(writer);
+ }
+ function WritableStreamDefaultWriterEnsureClosedPromiseRejected(writer, error) {
+  if (writer._closedPromiseState === 'pending') {
+   defaultWriterClosedPromiseReject(writer, error);
+  } else {
+   defaultWriterClosedPromiseResetToRejected(writer, error);
+  }
+ }
+ function WritableStreamDefaultWriterEnsureReadyPromiseRejected(writer, error) {
+  if (writer._readyPromiseState === 'pending') {
+   defaultWriterReadyPromiseReject(writer, error);
+  } else {
+   defaultWriterReadyPromiseResetToRejected(writer, error);
+  }
+ }
+ function WritableStreamDefaultWriterGetDesiredSize(writer) {
+  var stream = writer._ownerWritableStream;
+  var state = stream._state;
+  if (state === 'errored' || state === 'erroring') {
+   return null;
+  }
+  if (state === 'closed') {
+   return 0;
+  }
+  return WritableStreamDefaultControllerGetDesiredSize(stream._writableStreamController);
+ }
+ function WritableStreamDefaultWriterRelease(writer) {
+  var stream = writer._ownerWritableStream;
+  var releasedError = new TypeError('Writer was released and can no longer be used to monitor the stream\'s closedness');
+  WritableStreamDefaultWriterEnsureReadyPromiseRejected(writer, releasedError);
+  WritableStreamDefaultWriterEnsureClosedPromiseRejected(writer, releasedError);
+  stream._writer = undefined;
+  writer._ownerWritableStream = undefined;
+ }
+ function WritableStreamDefaultWriterWrite(writer, chunk) {
+  var stream = writer._ownerWritableStream;
+  var controller = stream._writableStreamController;
+  var chunkSize = WritableStreamDefaultControllerGetChunkSize(controller, chunk);
+  if (stream !== writer._ownerWritableStream) {
+   return promiseRejectedWith(defaultWriterLockException('write to'));
+  }
+  var state = stream._state;
+  if (state === 'errored') {
+   return promiseRejectedWith(stream._storedError);
+  }
+  if (WritableStreamCloseQueuedOrInFlight(stream) === true || state === 'closed') {
+   return promiseRejectedWith(new TypeError('The stream is closing or closed and cannot be written to'));
+  }
+  if (state === 'erroring') {
+   return promiseRejectedWith(stream._storedError);
+  }
+  var promise = WritableStreamAddWriteRequest(stream);
+  WritableStreamDefaultControllerWrite(controller, chunk, chunkSize);
+  return promise;
+ }
+ var WritableStreamDefaultController = function () {
+  function WritableStreamDefaultController() {
+   throw new TypeError('WritableStreamDefaultController cannot be constructed explicitly');
+  }
+  WritableStreamDefaultController.prototype.error = function (e) {
+   if (IsWritableStreamDefaultController(this) === false) {
+    throw new TypeError('WritableStreamDefaultController.prototype.error can only be used on a WritableStreamDefaultController');
+   }
+   var state = this._controlledWritableStream._state;
+   if (state !== 'writable') {
+    return;
+   }
+   WritableStreamDefaultControllerError(this, e);
+  };
+  WritableStreamDefaultController.prototype[AbortSteps] = function (reason) {
+   var result = this._abortAlgorithm(reason);
+   WritableStreamDefaultControllerClearAlgorithms(this);
+   return result;
+  };
+  WritableStreamDefaultController.prototype[ErrorSteps] = function () {
+   ResetQueue(this);
+  };
+  return WritableStreamDefaultController;
+ }();
+ function IsWritableStreamDefaultController(x) {
+  if (!typeIsObject(x)) {
+   return false;
+  }
+  if (!Object.prototype.hasOwnProperty.call(x, '_controlledWritableStream')) {
+   return false;
+  }
+  return true;
+ }
+ function SetUpWritableStreamDefaultController(stream, controller, startAlgorithm, writeAlgorithm, closeAlgorithm, abortAlgorithm, highWaterMark, sizeAlgorithm) {
+  controller._controlledWritableStream = stream;
+  stream._writableStreamController = controller;
+  controller._queue = undefined;
+  controller._queueTotalSize = undefined;
+  ResetQueue(controller);
+  controller._started = false;
+  controller._strategySizeAlgorithm = sizeAlgorithm;
+  controller._strategyHWM = highWaterMark;
+  controller._writeAlgorithm = writeAlgorithm;
+  controller._closeAlgorithm = closeAlgorithm;
+  controller._abortAlgorithm = abortAlgorithm;
+  var backpressure = WritableStreamDefaultControllerGetBackpressure(controller);
+  WritableStreamUpdateBackpressure(stream, backpressure);
+  var startResult = startAlgorithm();
+  var startPromise = promiseResolvedWith(startResult);
+  uponPromise(startPromise, function () {
+   controller._started = true;
+   WritableStreamDefaultControllerAdvanceQueueIfNeeded(controller);
+  }, function (r) {
+   controller._started = true;
+   WritableStreamDealWithRejection(stream, r);
+  });
+ }
+ function SetUpWritableStreamDefaultControllerFromUnderlyingSink(stream, underlyingSink, highWaterMark, sizeAlgorithm) {
+  var controller = Object.create(WritableStreamDefaultController.prototype);
+  function startAlgorithm() {
+   return InvokeOrNoop(underlyingSink, 'start', [controller]);
+  }
+  var writeAlgorithm = CreateAlgorithmFromUnderlyingMethod(underlyingSink, 'write', 1, [controller]);
+  var closeAlgorithm = CreateAlgorithmFromUnderlyingMethod(underlyingSink, 'close', 0, []);
+  var abortAlgorithm = CreateAlgorithmFromUnderlyingMethod(underlyingSink, 'abort', 1, []);
+  SetUpWritableStreamDefaultController(stream, controller, startAlgorithm, writeAlgorithm, closeAlgorithm, abortAlgorithm, highWaterMark, sizeAlgorithm);
+ }
+ function WritableStreamDefaultControllerClearAlgorithms(controller) {
+  controller._writeAlgorithm = undefined;
+  controller._closeAlgorithm = undefined;
+  controller._abortAlgorithm = undefined;
+  controller._strategySizeAlgorithm = undefined;
+ }
+ function WritableStreamDefaultControllerClose(controller) {
+  EnqueueValueWithSize(controller, 'close', 0);
+  WritableStreamDefaultControllerAdvanceQueueIfNeeded(controller);
+ }
+ function WritableStreamDefaultControllerGetChunkSize(controller, chunk) {
+  try {
+   return controller._strategySizeAlgorithm(chunk);
+  } catch (chunkSizeE) {
+   WritableStreamDefaultControllerErrorIfNeeded(controller, chunkSizeE);
+   return 1;
+  }
+ }
+ function WritableStreamDefaultControllerGetDesiredSize(controller) {
+  return controller._strategyHWM - controller._queueTotalSize;
+ }
+ function WritableStreamDefaultControllerWrite(controller, chunk, chunkSize) {
+  var writeRecord = { chunk: chunk };
+  try {
+   EnqueueValueWithSize(controller, writeRecord, chunkSize);
+  } catch (enqueueE) {
+   WritableStreamDefaultControllerErrorIfNeeded(controller, enqueueE);
+   return;
+  }
+  var stream = controller._controlledWritableStream;
+  if (WritableStreamCloseQueuedOrInFlight(stream) === false && stream._state === 'writable') {
+   var backpressure = WritableStreamDefaultControllerGetBackpressure(controller);
+   WritableStreamUpdateBackpressure(stream, backpressure);
+  }
+  WritableStreamDefaultControllerAdvanceQueueIfNeeded(controller);
+ }
+ function WritableStreamDefaultControllerAdvanceQueueIfNeeded(controller) {
+  var stream = controller._controlledWritableStream;
+  if (controller._started === false) {
+   return;
+  }
+  if (stream._inFlightWriteRequest !== undefined) {
+   return;
+  }
+  var state = stream._state;
+  if (state === 'erroring') {
+   WritableStreamFinishErroring(stream);
+   return;
+  }
+  if (controller._queue.length === 0) {
+   return;
+  }
+  var writeRecord = PeekQueueValue(controller);
+  if (writeRecord === 'close') {
+   WritableStreamDefaultControllerProcessClose(controller);
+  } else {
+   WritableStreamDefaultControllerProcessWrite(controller, writeRecord.chunk);
+  }
+ }
+ function WritableStreamDefaultControllerErrorIfNeeded(controller, error) {
+  if (controller._controlledWritableStream._state === 'writable') {
+   WritableStreamDefaultControllerError(controller, error);
+  }
+ }
+ function WritableStreamDefaultControllerProcessClose(controller) {
+  var stream = controller._controlledWritableStream;
+  WritableStreamMarkCloseRequestInFlight(stream);
+  DequeueValue(controller);
+  var sinkClosePromise = controller._closeAlgorithm();
+  WritableStreamDefaultControllerClearAlgorithms(controller);
+  uponPromise(sinkClosePromise, function () {
+   WritableStreamFinishInFlightClose(stream);
+  }, function (reason) {
+   WritableStreamFinishInFlightCloseWithError(stream, reason);
+  });
+ }
+ function WritableStreamDefaultControllerProcessWrite(controller, chunk) {
+  var stream = controller._controlledWritableStream;
+  WritableStreamMarkFirstWriteRequestInFlight(stream);
+  var sinkWritePromise = controller._writeAlgorithm(chunk);
+  uponPromise(sinkWritePromise, function () {
+   WritableStreamFinishInFlightWrite(stream);
+   var state = stream._state;
+   DequeueValue(controller);
+   if (WritableStreamCloseQueuedOrInFlight(stream) === false && state === 'writable') {
+    var backpressure = WritableStreamDefaultControllerGetBackpressure(controller);
+    WritableStreamUpdateBackpressure(stream, backpressure);
+   }
+   WritableStreamDefaultControllerAdvanceQueueIfNeeded(controller);
+  }, function (reason) {
+   if (stream._state === 'writable') {
+    WritableStreamDefaultControllerClearAlgorithms(controller);
+   }
+   WritableStreamFinishInFlightWriteWithError(stream, reason);
+  });
+ }
+ function WritableStreamDefaultControllerGetBackpressure(controller) {
+  var desiredSize = WritableStreamDefaultControllerGetDesiredSize(controller);
+  return desiredSize <= 0;
+ }
+ function WritableStreamDefaultControllerError(controller, error) {
+  var stream = controller._controlledWritableStream;
+  WritableStreamDefaultControllerClearAlgorithms(controller);
+  WritableStreamStartErroring(stream, error);
+ }
+ function streamBrandCheckException(name) {
+  return new TypeError("WritableStream.prototype." + name + " can only be used on a WritableStream");
+ }
+ function defaultWriterBrandCheckException(name) {
+  return new TypeError("WritableStreamDefaultWriter.prototype." + name + " can only be used on a WritableStreamDefaultWriter");
+ }
+ function defaultWriterLockException(name) {
+  return new TypeError('Cannot ' + name + ' a stream using a released writer');
+ }
+ function defaultWriterClosedPromiseInitialize(writer) {
+  writer._closedPromise = newPromise(function (resolve, reject) {
+   writer._closedPromise_resolve = resolve;
+   writer._closedPromise_reject = reject;
+   writer._closedPromiseState = 'pending';
+  });
+ }
+ function defaultWriterClosedPromiseInitializeAsRejected(writer, reason) {
+  defaultWriterClosedPromiseInitialize(writer);
+  defaultWriterClosedPromiseReject(writer, reason);
+ }
+ function defaultWriterClosedPromiseInitializeAsResolved(writer) {
+  defaultWriterClosedPromiseInitialize(writer);
+  defaultWriterClosedPromiseResolve(writer);
+ }
+ function defaultWriterClosedPromiseReject(writer, reason) {
+  setPromiseIsHandledToTrue(writer._closedPromise);
+  writer._closedPromise_reject(reason);
+  writer._closedPromise_resolve = undefined;
+  writer._closedPromise_reject = undefined;
+  writer._closedPromiseState = 'rejected';
+ }
+ function defaultWriterClosedPromiseResetToRejected(writer, reason) {
+  defaultWriterClosedPromiseInitializeAsRejected(writer, reason);
+ }
+ function defaultWriterClosedPromiseResolve(writer) {
+  writer._closedPromise_resolve(undefined);
+  writer._closedPromise_resolve = undefined;
+  writer._closedPromise_reject = undefined;
+  writer._closedPromiseState = 'resolved';
+ }
+ function defaultWriterReadyPromiseInitialize(writer) {
+  writer._readyPromise = newPromise(function (resolve, reject) {
+   writer._readyPromise_resolve = resolve;
+   writer._readyPromise_reject = reject;
+  });
+  writer._readyPromiseState = 'pending';
+ }
+ function defaultWriterReadyPromiseInitializeAsRejected(writer, reason) {
+  defaultWriterReadyPromiseInitialize(writer);
+  defaultWriterReadyPromiseReject(writer, reason);
+ }
+ function defaultWriterReadyPromiseInitializeAsResolved(writer) {
+  defaultWriterReadyPromiseInitialize(writer);
+  defaultWriterReadyPromiseResolve(writer);
+ }
+ function defaultWriterReadyPromiseReject(writer, reason) {
+  setPromiseIsHandledToTrue(writer._readyPromise);
+  writer._readyPromise_reject(reason);
+  writer._readyPromise_resolve = undefined;
+  writer._readyPromise_reject = undefined;
+  writer._readyPromiseState = 'rejected';
+ }
+ function defaultWriterReadyPromiseReset(writer) {
+  defaultWriterReadyPromiseInitialize(writer);
+ }
+ function defaultWriterReadyPromiseResetToRejected(writer, reason) {
+  defaultWriterReadyPromiseInitializeAsRejected(writer, reason);
+ }
+ function defaultWriterReadyPromiseResolve(writer) {
+  writer._readyPromise_resolve(undefined);
+  writer._readyPromise_resolve = undefined;
+  writer._readyPromise_reject = undefined;
+  writer._readyPromiseState = 'fulfilled';
+ }
+ function isAbortSignal(value) {
+  if (typeof value !== 'object' || value === null) {
+   return false;
+  }
+  try {
+   return typeof value.aborted === 'boolean';
+  } catch (_a) {
+   return false;
+  }
+ }
+ var NativeDOMException = typeof DOMException !== 'undefined' ? DOMException : undefined;
+ function isDOMExceptionConstructor(ctor) {
+  if (!(typeof ctor === 'function' || typeof ctor === 'object')) {
+   return false;
+  }
+  try {
+   new ctor();
+   return true;
+  } catch (_a) {
+   return false;
+  }
+ }
+ function createDOMExceptionPolyfill() {
+  var ctor = function DOMException(message, name) {
+   this.message = message || '';
+   this.name = name || 'Error';
+   if (Error.captureStackTrace) {
+    Error.captureStackTrace(this, this.constructor);
+   }
+  };
+  ctor.prototype = Object.create(Error.prototype);
+  Object.defineProperty(ctor.prototype, 'constructor', {
+   value: ctor,
+   writable: true,
+   configurable: true
+  });
+  return ctor;
+ }
+ var DOMException$1 = isDOMExceptionConstructor(NativeDOMException) ? NativeDOMException : createDOMExceptionPolyfill();
+ function ReadableStreamPipeTo(source, dest, preventClose, preventAbort, preventCancel, signal) {
+  var reader = AcquireReadableStreamDefaultReader(source);
+  var writer = AcquireWritableStreamDefaultWriter(dest);
+  source._disturbed = true;
+  var shuttingDown = false;
+  var currentWrite = promiseResolvedWith(undefined);
+  return newPromise(function (resolve, reject) {
+   var abortAlgorithm;
+   if (signal !== undefined) {
+    abortAlgorithm = function () {
+     var error = new DOMException$1('Aborted', 'AbortError');
+     var actions = [];
+     if (preventAbort === false) {
+      actions.push(function () {
+       if (dest._state === 'writable') {
+        return WritableStreamAbort(dest, error);
+       }
+       return promiseResolvedWith(undefined);
+      });
+     }
+     if (preventCancel === false) {
+      actions.push(function () {
+       if (source._state === 'readable') {
+        return ReadableStreamCancel(source, error);
+       }
+       return promiseResolvedWith(undefined);
+      });
+     }
+     shutdownWithAction(function () {
+      return Promise.all(actions.map(function (action) {
+       return action();
+      }));
+     }, true, error);
+    };
+    if (signal.aborted === true) {
+     abortAlgorithm();
+     return;
+    }
+    signal.addEventListener('abort', abortAlgorithm);
+   }
+   function pipeLoop() {
+    return newPromise(function (resolveLoop, rejectLoop) {
+     function next(done) {
+      if (done) {
+       resolveLoop();
+      } else {
+       PerformPromiseThen(pipeStep(), next, rejectLoop);
+      }
+     }
+     next(false);
+    });
+   }
+   function pipeStep() {
+    if (shuttingDown === true) {
+     return promiseResolvedWith(true);
+    }
+    return PerformPromiseThen(writer._readyPromise, function () {
+     return PerformPromiseThen(ReadableStreamDefaultReaderRead(reader), function (result) {
+      if (result.done === true) {
+       return true;
+      }
+      currentWrite = PerformPromiseThen(WritableStreamDefaultWriterWrite(writer, result.value), undefined, noop);
+      return false;
+     });
+    });
+   }
+   isOrBecomesErrored(source, reader._closedPromise, function (storedError) {
+    if (preventAbort === false) {
+     shutdownWithAction(function () {
+      return WritableStreamAbort(dest, storedError);
+     }, true, storedError);
+    } else {
+     shutdown(true, storedError);
+    }
+   });
+   isOrBecomesErrored(dest, writer._closedPromise, function (storedError) {
+    if (preventCancel === false) {
+     shutdownWithAction(function () {
+      return ReadableStreamCancel(source, storedError);
+     }, true, storedError);
+    } else {
+     shutdown(true, storedError);
+    }
+   });
+   isOrBecomesClosed(source, reader._closedPromise, function () {
+    if (preventClose === false) {
+     shutdownWithAction(function () {
+      return WritableStreamDefaultWriterCloseWithErrorPropagation(writer);
+     });
+    } else {
+     shutdown();
+    }
+   });
+   if (WritableStreamCloseQueuedOrInFlight(dest) === true || dest._state === 'closed') {
+    var destClosed_1 = new TypeError('the destination writable stream closed before all data could be piped to it');
+    if (preventCancel === false) {
+     shutdownWithAction(function () {
+      return ReadableStreamCancel(source, destClosed_1);
+     }, true, destClosed_1);
+    } else {
+     shutdown(true, destClosed_1);
+    }
+   }
+   setPromiseIsHandledToTrue(pipeLoop());
+   function waitForWritesToFinish() {
+    var oldCurrentWrite = currentWrite;
+    return PerformPromiseThen(currentWrite, function () {
+     return oldCurrentWrite !== currentWrite ? waitForWritesToFinish() : undefined;
+    });
+   }
+   function isOrBecomesErrored(stream, promise, action) {
+    if (stream._state === 'errored') {
+     action(stream._storedError);
+    } else {
+     uponRejection(promise, action);
+    }
+   }
+   function isOrBecomesClosed(stream, promise, action) {
+    if (stream._state === 'closed') {
+     action();
+    } else {
+     uponFulfillment(promise, action);
+    }
+   }
+   function shutdownWithAction(action, originalIsError, originalError) {
+    if (shuttingDown === true) {
+     return;
+    }
+    shuttingDown = true;
+    if (dest._state === 'writable' && WritableStreamCloseQueuedOrInFlight(dest) === false) {
+     uponFulfillment(waitForWritesToFinish(), doTheRest);
+    } else {
+     doTheRest();
+    }
+    function doTheRest() {
+     uponPromise(action(), function () {
+      return finalize(originalIsError, originalError);
+     }, function (newError) {
+      return finalize(true, newError);
+     });
+    }
+   }
+   function shutdown(isError, error) {
+    if (shuttingDown === true) {
+     return;
+    }
+    shuttingDown = true;
+    if (dest._state === 'writable' && WritableStreamCloseQueuedOrInFlight(dest) === false) {
+     uponFulfillment(waitForWritesToFinish(), function () {
+      return finalize(isError, error);
+     });
+    } else {
+     finalize(isError, error);
+    }
+   }
+   function finalize(isError, error) {
+    WritableStreamDefaultWriterRelease(writer);
+    ReadableStreamReaderGenericRelease(reader);
+    if (signal !== undefined) {
+     signal.removeEventListener('abort', abortAlgorithm);
+    }
+    if (isError) {
+     reject(error);
+    } else {
+     resolve(undefined);
+    }
+   }
+  });
+ }
+ var ReadableStreamDefaultController = function () {
+  function ReadableStreamDefaultController() {
+   throw new TypeError();
+  }
+  Object.defineProperty(ReadableStreamDefaultController.prototype, "desiredSize", {
+   get: function () {
+    if (IsReadableStreamDefaultController(this) === false) {
+     throw defaultControllerBrandCheckException('desiredSize');
+    }
+    return ReadableStreamDefaultControllerGetDesiredSize(this);
+   },
+   enumerable: true,
+   configurable: true
+  });
+  ReadableStreamDefaultController.prototype.close = function () {
+   if (IsReadableStreamDefaultController(this) === false) {
+    throw defaultControllerBrandCheckException('close');
+   }
+   if (ReadableStreamDefaultControllerCanCloseOrEnqueue(this) === false) {
+    throw new TypeError('The stream is not in a state that permits close');
+   }
+   ReadableStreamDefaultControllerClose(this);
+  };
+  ReadableStreamDefaultController.prototype.enqueue = function (chunk) {
+   if (IsReadableStreamDefaultController(this) === false) {
+    throw defaultControllerBrandCheckException('enqueue');
+   }
+   if (ReadableStreamDefaultControllerCanCloseOrEnqueue(this) === false) {
+    throw new TypeError('The stream is not in a state that permits enqueue');
+   }
+   return ReadableStreamDefaultControllerEnqueue(this, chunk);
+  };
+  ReadableStreamDefaultController.prototype.error = function (e) {
+   if (IsReadableStreamDefaultController(this) === false) {
+    throw defaultControllerBrandCheckException('error');
+   }
+   ReadableStreamDefaultControllerError(this, e);
+  };
+  ReadableStreamDefaultController.prototype[CancelSteps] = function (reason) {
+   ResetQueue(this);
+   var result = this._cancelAlgorithm(reason);
+   ReadableStreamDefaultControllerClearAlgorithms(this);
+   return result;
+  };
+  ReadableStreamDefaultController.prototype[PullSteps] = function () {
+   var stream = this._controlledReadableStream;
+   if (this._queue.length > 0) {
+    var chunk = DequeueValue(this);
+    if (this._closeRequested === true && this._queue.length === 0) {
+     ReadableStreamDefaultControllerClearAlgorithms(this);
+     ReadableStreamClose(stream);
+    } else {
+     ReadableStreamDefaultControllerCallPullIfNeeded(this);
+    }
+    return promiseResolvedWith(ReadableStreamCreateReadResult(chunk, false, stream._reader._forAuthorCode));
+   }
+   var pendingPromise = ReadableStreamAddReadRequest(stream);
+   ReadableStreamDefaultControllerCallPullIfNeeded(this);
+   return pendingPromise;
+  };
+  return ReadableStreamDefaultController;
+ }();
+ function IsReadableStreamDefaultController(x) {
+  if (!typeIsObject(x)) {
+   return false;
+  }
+  if (!Object.prototype.hasOwnProperty.call(x, '_controlledReadableStream')) {
+   return false;
+  }
+  return true;
+ }
+ function ReadableStreamDefaultControllerCallPullIfNeeded(controller) {
+  var shouldPull = ReadableStreamDefaultControllerShouldCallPull(controller);
+  if (shouldPull === false) {
+   return;
+  }
+  if (controller._pulling === true) {
+   controller._pullAgain = true;
+   return;
+  }
+  controller._pulling = true;
+  var pullPromise = controller._pullAlgorithm();
+  uponPromise(pullPromise, function () {
+   controller._pulling = false;
+   if (controller._pullAgain === true) {
+    controller._pullAgain = false;
+    ReadableStreamDefaultControllerCallPullIfNeeded(controller);
+   }
+  }, function (e) {
+   ReadableStreamDefaultControllerError(controller, e);
+  });
+ }
+ function ReadableStreamDefaultControllerShouldCallPull(controller) {
+  var stream = controller._controlledReadableStream;
+  if (ReadableStreamDefaultControllerCanCloseOrEnqueue(controller) === false) {
+   return false;
+  }
+  if (controller._started === false) {
+   return false;
+  }
+  if (IsReadableStreamLocked(stream) === true && ReadableStreamGetNumReadRequests(stream) > 0) {
+   return true;
+  }
+  var desiredSize = ReadableStreamDefaultControllerGetDesiredSize(controller);
+  if (desiredSize > 0) {
+   return true;
+  }
+  return false;
+ }
+ function ReadableStreamDefaultControllerClearAlgorithms(controller) {
+  controller._pullAlgorithm = undefined;
+  controller._cancelAlgorithm = undefined;
+  controller._strategySizeAlgorithm = undefined;
+ }
+ function ReadableStreamDefaultControllerClose(controller) {
+  var stream = controller._controlledReadableStream;
+  controller._closeRequested = true;
+  if (controller._queue.length === 0) {
+   ReadableStreamDefaultControllerClearAlgorithms(controller);
+   ReadableStreamClose(stream);
+  }
+ }
+ function ReadableStreamDefaultControllerEnqueue(controller, chunk) {
+  var stream = controller._controlledReadableStream;
+  if (IsReadableStreamLocked(stream) === true && ReadableStreamGetNumReadRequests(stream) > 0) {
+   ReadableStreamFulfillReadRequest(stream, chunk, false);
+  } else {
+   var chunkSize = void 0;
+   try {
+    chunkSize = controller._strategySizeAlgorithm(chunk);
+   } catch (chunkSizeE) {
+    ReadableStreamDefaultControllerError(controller, chunkSizeE);
+    throw chunkSizeE;
+   }
+   try {
+    EnqueueValueWithSize(controller, chunk, chunkSize);
+   } catch (enqueueE) {
+    ReadableStreamDefaultControllerError(controller, enqueueE);
+    throw enqueueE;
+   }
+  }
+  ReadableStreamDefaultControllerCallPullIfNeeded(controller);
+ }
+ function ReadableStreamDefaultControllerError(controller, e) {
+  var stream = controller._controlledReadableStream;
+  if (stream._state !== 'readable') {
+   return;
+  }
+  ResetQueue(controller);
+  ReadableStreamDefaultControllerClearAlgorithms(controller);
+  ReadableStreamError(stream, e);
+ }
+ function ReadableStreamDefaultControllerGetDesiredSize(controller) {
+  var stream = controller._controlledReadableStream;
+  var state = stream._state;
+  if (state === 'errored') {
+   return null;
+  }
+  if (state === 'closed') {
+   return 0;
+  }
+  return controller._strategyHWM - controller._queueTotalSize;
+ }
+ function ReadableStreamDefaultControllerHasBackpressure(controller) {
+  if (ReadableStreamDefaultControllerShouldCallPull(controller) === true) {
+   return false;
+  }
+  return true;
+ }
+ function ReadableStreamDefaultControllerCanCloseOrEnqueue(controller) {
+  var state = controller._controlledReadableStream._state;
+  if (controller._closeRequested === false && state === 'readable') {
+   return true;
+  }
+  return false;
+ }
+ function SetUpReadableStreamDefaultController(stream, controller, startAlgorithm, pullAlgorithm, cancelAlgorithm, highWaterMark, sizeAlgorithm) {
+  controller._controlledReadableStream = stream;
+  controller._queue = undefined;
+  controller._queueTotalSize = undefined;
+  ResetQueue(controller);
+  controller._started = false;
+  controller._closeRequested = false;
+  controller._pullAgain = false;
+  controller._pulling = false;
+  controller._strategySizeAlgorithm = sizeAlgorithm;
+  controller._strategyHWM = highWaterMark;
+  controller._pullAlgorithm = pullAlgorithm;
+  controller._cancelAlgorithm = cancelAlgorithm;
+  stream._readableStreamController = controller;
+  var startResult = startAlgorithm();
+  uponPromise(promiseResolvedWith(startResult), function () {
+   controller._started = true;
+   ReadableStreamDefaultControllerCallPullIfNeeded(controller);
+  }, function (r) {
+   ReadableStreamDefaultControllerError(controller, r);
+  });
+ }
+ function SetUpReadableStreamDefaultControllerFromUnderlyingSource(stream, underlyingSource, highWaterMark, sizeAlgorithm) {
+  var controller = Object.create(ReadableStreamDefaultController.prototype);
+  function startAlgorithm() {
+   return InvokeOrNoop(underlyingSource, 'start', [controller]);
+  }
+  var pullAlgorithm = CreateAlgorithmFromUnderlyingMethod(underlyingSource, 'pull', 0, [controller]);
+  var cancelAlgorithm = CreateAlgorithmFromUnderlyingMethod(underlyingSource, 'cancel', 1, []);
+  SetUpReadableStreamDefaultController(stream, controller, startAlgorithm, pullAlgorithm, cancelAlgorithm, highWaterMark, sizeAlgorithm);
+ }
+ function defaultControllerBrandCheckException(name) {
+  return new TypeError("ReadableStreamDefaultController.prototype." + name + " can only be used on a ReadableStreamDefaultController");
+ }
+ function ReadableStreamTee(stream, cloneForBranch2) {
+  var reader = AcquireReadableStreamDefaultReader(stream);
+  var reading = false;
+  var canceled1 = false;
+  var canceled2 = false;
+  var reason1;
+  var reason2;
+  var branch1;
+  var branch2;
+  var resolveCancelPromise;
+  var cancelPromise = newPromise(function (resolve) {
+   resolveCancelPromise = resolve;
+  });
+  function pullAlgorithm() {
+   if (reading === true) {
+    return promiseResolvedWith(undefined);
+   }
+   reading = true;
+   var readPromise = transformPromiseWith(ReadableStreamDefaultReaderRead(reader), function (result) {
+    reading = false;
+    var done = result.done;
+    if (done === true) {
+     if (canceled1 === false) {
+      ReadableStreamDefaultControllerClose(branch1._readableStreamController);
+     }
+     if (canceled2 === false) {
+      ReadableStreamDefaultControllerClose(branch2._readableStreamController);
+     }
+     return;
+    }
+    var value = result.value;
+    var value1 = value;
+    var value2 = value;
+    if (canceled1 === false) {
+     ReadableStreamDefaultControllerEnqueue(branch1._readableStreamController, value1);
+    }
+    if (canceled2 === false) {
+     ReadableStreamDefaultControllerEnqueue(branch2._readableStreamController, value2);
+    }
+   });
+   setPromiseIsHandledToTrue(readPromise);
+   return promiseResolvedWith(undefined);
+  }
+  function cancel1Algorithm(reason) {
+   canceled1 = true;
+   reason1 = reason;
+   if (canceled2 === true) {
+    var compositeReason = createArrayFromList([
+     reason1,
+     reason2
+    ]);
+    var cancelResult = ReadableStreamCancel(stream, compositeReason);
+    resolveCancelPromise(cancelResult);
+   }
+   return cancelPromise;
+  }
+  function cancel2Algorithm(reason) {
+   canceled2 = true;
+   reason2 = reason;
+   if (canceled1 === true) {
+    var compositeReason = createArrayFromList([
+     reason1,
+     reason2
+    ]);
+    var cancelResult = ReadableStreamCancel(stream, compositeReason);
+    resolveCancelPromise(cancelResult);
+   }
+   return cancelPromise;
+  }
+  function startAlgorithm() {
+  }
+  branch1 = CreateReadableStream(startAlgorithm, pullAlgorithm, cancel1Algorithm);
+  branch2 = CreateReadableStream(startAlgorithm, pullAlgorithm, cancel2Algorithm);
+  uponRejection(reader._closedPromise, function (r) {
+   ReadableStreamDefaultControllerError(branch1._readableStreamController, r);
+   ReadableStreamDefaultControllerError(branch2._readableStreamController, r);
+  });
+  return [
+   branch1,
+   branch2
+  ];
+ }
+ var NumberIsInteger = Number.isInteger || function (value) {
+  return typeof value === 'number' && isFinite(value) && Math.floor(value) === value;
+ };
+ var ReadableStreamBYOBRequest = function () {
+  function ReadableStreamBYOBRequest() {
+   throw new TypeError('ReadableStreamBYOBRequest cannot be used directly');
+  }
+  Object.defineProperty(ReadableStreamBYOBRequest.prototype, "view", {
+   get: function () {
+    if (IsReadableStreamBYOBRequest(this) === false) {
+     throw byobRequestBrandCheckException('view');
+    }
+    return this._view;
+   },
+   enumerable: true,
+   configurable: true
+  });
+  ReadableStreamBYOBRequest.prototype.respond = function (bytesWritten) {
+   if (IsReadableStreamBYOBRequest(this) === false) {
+    throw byobRequestBrandCheckException('respond');
+   }
+   if (this._associatedReadableByteStreamController === undefined) {
+    throw new TypeError('This BYOB request has been invalidated');
+   }
+   if (IsDetachedBuffer(this._view.buffer) === true);
+   ReadableByteStreamControllerRespond(this._associatedReadableByteStreamController, bytesWritten);
+  };
+  ReadableStreamBYOBRequest.prototype.respondWithNewView = function (view) {
+   if (IsReadableStreamBYOBRequest(this) === false) {
+    throw byobRequestBrandCheckException('respond');
+   }
+   if (this._associatedReadableByteStreamController === undefined) {
+    throw new TypeError('This BYOB request has been invalidated');
+   }
+   if (!ArrayBuffer.isView(view)) {
+    throw new TypeError('You can only respond with array buffer views');
+   }
+   if (IsDetachedBuffer(view.buffer) === true);
+   ReadableByteStreamControllerRespondWithNewView(this._associatedReadableByteStreamController, view);
+  };
+  return ReadableStreamBYOBRequest;
+ }();
+ var ReadableByteStreamController = function () {
+  function ReadableByteStreamController() {
+   throw new TypeError('ReadableByteStreamController constructor cannot be used directly');
+  }
+  Object.defineProperty(ReadableByteStreamController.prototype, "byobRequest", {
+   get: function () {
+    if (IsReadableByteStreamController(this) === false) {
+     throw byteStreamControllerBrandCheckException('byobRequest');
+    }
+    if (this._byobRequest === undefined && this._pendingPullIntos.length > 0) {
+     var firstDescriptor = this._pendingPullIntos.peek();
+     var view = new Uint8Array(firstDescriptor.buffer, firstDescriptor.byteOffset + firstDescriptor.bytesFilled, firstDescriptor.byteLength - firstDescriptor.bytesFilled);
+     var byobRequest = Object.create(ReadableStreamBYOBRequest.prototype);
+     SetUpReadableStreamBYOBRequest(byobRequest, this, view);
+     this._byobRequest = byobRequest;
+    }
+    return this._byobRequest;
+   },
+   enumerable: true,
+   configurable: true
+  });
+  Object.defineProperty(ReadableByteStreamController.prototype, "desiredSize", {
+   get: function () {
+    if (IsReadableByteStreamController(this) === false) {
+     throw byteStreamControllerBrandCheckException('desiredSize');
+    }
+    return ReadableByteStreamControllerGetDesiredSize(this);
+   },
+   enumerable: true,
+   configurable: true
+  });
+  ReadableByteStreamController.prototype.close = function () {
+   if (IsReadableByteStreamController(this) === false) {
+    throw byteStreamControllerBrandCheckException('close');
+   }
+   if (this._closeRequested === true) {
+    throw new TypeError('The stream has already been closed; do not close it again!');
+   }
+   var state = this._controlledReadableByteStream._state;
+   if (state !== 'readable') {
+    throw new TypeError("The stream (in " + state + " state) is not in the readable state and cannot be closed");
+   }
+   ReadableByteStreamControllerClose(this);
+  };
+  ReadableByteStreamController.prototype.enqueue = function (chunk) {
+   if (IsReadableByteStreamController(this) === false) {
+    throw byteStreamControllerBrandCheckException('enqueue');
+   }
+   if (this._closeRequested === true) {
+    throw new TypeError('stream is closed or draining');
+   }
+   var state = this._controlledReadableByteStream._state;
+   if (state !== 'readable') {
+    throw new TypeError("The stream (in " + state + " state) is not in the readable state and cannot be enqueued to");
+   }
+   if (!ArrayBuffer.isView(chunk)) {
+    throw new TypeError('You can only enqueue array buffer views when using a ReadableByteStreamController');
+   }
+   if (IsDetachedBuffer(chunk.buffer) === true);
+   ReadableByteStreamControllerEnqueue(this, chunk);
+  };
+  ReadableByteStreamController.prototype.error = function (e) {
+   if (IsReadableByteStreamController(this) === false) {
+    throw byteStreamControllerBrandCheckException('error');
+   }
+   ReadableByteStreamControllerError(this, e);
+  };
+  ReadableByteStreamController.prototype[CancelSteps] = function (reason) {
+   if (this._pendingPullIntos.length > 0) {
+    var firstDescriptor = this._pendingPullIntos.peek();
+    firstDescriptor.bytesFilled = 0;
+   }
+   ResetQueue(this);
+   var result = this._cancelAlgorithm(reason);
+   ReadableByteStreamControllerClearAlgorithms(this);
+   return result;
+  };
+  ReadableByteStreamController.prototype[PullSteps] = function () {
+   var stream = this._controlledReadableByteStream;
+   if (this._queueTotalSize > 0) {
+    var entry = this._queue.shift();
+    this._queueTotalSize -= entry.byteLength;
+    ReadableByteStreamControllerHandleQueueDrain(this);
+    var view = void 0;
+    try {
+     view = new Uint8Array(entry.buffer, entry.byteOffset, entry.byteLength);
+    } catch (viewE) {
+     return promiseRejectedWith(viewE);
+    }
+    return promiseResolvedWith(ReadableStreamCreateReadResult(view, false, stream._reader._forAuthorCode));
+   }
+   var autoAllocateChunkSize = this._autoAllocateChunkSize;
+   if (autoAllocateChunkSize !== undefined) {
+    var buffer = void 0;
+    try {
+     buffer = new ArrayBuffer(autoAllocateChunkSize);
+    } catch (bufferE) {
+     return promiseRejectedWith(bufferE);
+    }
+    var pullIntoDescriptor = {
+     buffer: buffer,
+     byteOffset: 0,
+     byteLength: autoAllocateChunkSize,
+     bytesFilled: 0,
+     elementSize: 1,
+     ctor: Uint8Array,
+     readerType: 'default'
+    };
+    this._pendingPullIntos.push(pullIntoDescriptor);
+   }
+   var promise = ReadableStreamAddReadRequest(stream);
+   ReadableByteStreamControllerCallPullIfNeeded(this);
+   return promise;
+  };
+  return ReadableByteStreamController;
+ }();
+ function IsReadableByteStreamController(x) {
+  if (!typeIsObject(x)) {
+   return false;
+  }
+  if (!Object.prototype.hasOwnProperty.call(x, '_controlledReadableByteStream')) {
+   return false;
+  }
+  return true;
+ }
+ function IsReadableStreamBYOBRequest(x) {
+  if (!typeIsObject(x)) {
+   return false;
+  }
+  if (!Object.prototype.hasOwnProperty.call(x, '_associatedReadableByteStreamController')) {
+   return false;
+  }
+  return true;
+ }
+ function ReadableByteStreamControllerCallPullIfNeeded(controller) {
+  var shouldPull = ReadableByteStreamControllerShouldCallPull(controller);
+  if (shouldPull === false) {
+   return;
+  }
+  if (controller._pulling === true) {
+   controller._pullAgain = true;
+   return;
+  }
+  controller._pulling = true;
+  var pullPromise = controller._pullAlgorithm();
+  uponPromise(pullPromise, function () {
+   controller._pulling = false;
+   if (controller._pullAgain === true) {
+    controller._pullAgain = false;
+    ReadableByteStreamControllerCallPullIfNeeded(controller);
+   }
+  }, function (e) {
+   ReadableByteStreamControllerError(controller, e);
+  });
+ }
+ function ReadableByteStreamControllerClearPendingPullIntos(controller) {
+  ReadableByteStreamControllerInvalidateBYOBRequest(controller);
+  controller._pendingPullIntos = new SimpleQueue();
+ }
+ function ReadableByteStreamControllerCommitPullIntoDescriptor(stream, pullIntoDescriptor) {
+  var done = false;
+  if (stream._state === 'closed') {
+   done = true;
+  }
+  var filledView = ReadableByteStreamControllerConvertPullIntoDescriptor(pullIntoDescriptor);
+  if (pullIntoDescriptor.readerType === 'default') {
+   ReadableStreamFulfillReadRequest(stream, filledView, done);
+  } else {
+   ReadableStreamFulfillReadIntoRequest(stream, filledView, done);
+  }
+ }
+ function ReadableByteStreamControllerConvertPullIntoDescriptor(pullIntoDescriptor) {
+  var bytesFilled = pullIntoDescriptor.bytesFilled;
+  var elementSize = pullIntoDescriptor.elementSize;
+  return new pullIntoDescriptor.ctor(pullIntoDescriptor.buffer, pullIntoDescriptor.byteOffset, bytesFilled / elementSize);
+ }
+ function ReadableByteStreamControllerEnqueueChunkToQueue(controller, buffer, byteOffset, byteLength) {
+  controller._queue.push({
+   buffer: buffer,
+   byteOffset: byteOffset,
+   byteLength: byteLength
+  });
+  controller._queueTotalSize += byteLength;
+ }
+ function ReadableByteStreamControllerFillPullIntoDescriptorFromQueue(controller, pullIntoDescriptor) {
+  var elementSize = pullIntoDescriptor.elementSize;
+  var currentAlignedBytes = pullIntoDescriptor.bytesFilled - pullIntoDescriptor.bytesFilled % elementSize;
+  var maxBytesToCopy = Math.min(controller._queueTotalSize, pullIntoDescriptor.byteLength - pullIntoDescriptor.bytesFilled);
+  var maxBytesFilled = pullIntoDescriptor.bytesFilled + maxBytesToCopy;
+  var maxAlignedBytes = maxBytesFilled - maxBytesFilled % elementSize;
+  var totalBytesToCopyRemaining = maxBytesToCopy;
+  var ready = false;
+  if (maxAlignedBytes > currentAlignedBytes) {
+   totalBytesToCopyRemaining = maxAlignedBytes - pullIntoDescriptor.bytesFilled;
+   ready = true;
+  }
+  var queue = controller._queue;
+  while (totalBytesToCopyRemaining > 0) {
+   var headOfQueue = queue.peek();
+   var bytesToCopy = Math.min(totalBytesToCopyRemaining, headOfQueue.byteLength);
+   var destStart = pullIntoDescriptor.byteOffset + pullIntoDescriptor.bytesFilled;
+   ArrayBufferCopy(pullIntoDescriptor.buffer, destStart, headOfQueue.buffer, headOfQueue.byteOffset, bytesToCopy);
+   if (headOfQueue.byteLength === bytesToCopy) {
+    queue.shift();
+   } else {
+    headOfQueue.byteOffset += bytesToCopy;
+    headOfQueue.byteLength -= bytesToCopy;
+   }
+   controller._queueTotalSize -= bytesToCopy;
+   ReadableByteStreamControllerFillHeadPullIntoDescriptor(controller, bytesToCopy, pullIntoDescriptor);
+   totalBytesToCopyRemaining -= bytesToCopy;
+  }
+  return ready;
+ }
+ function ReadableByteStreamControllerFillHeadPullIntoDescriptor(controller, size, pullIntoDescriptor) {
+  ReadableByteStreamControllerInvalidateBYOBRequest(controller);
+  pullIntoDescriptor.bytesFilled += size;
+ }
+ function ReadableByteStreamControllerHandleQueueDrain(controller) {
+  if (controller._queueTotalSize === 0 && controller._closeRequested === true) {
+   ReadableByteStreamControllerClearAlgorithms(controller);
+   ReadableStreamClose(controller._controlledReadableByteStream);
+  } else {
+   ReadableByteStreamControllerCallPullIfNeeded(controller);
+  }
+ }
+ function ReadableByteStreamControllerInvalidateBYOBRequest(controller) {
+  if (controller._byobRequest === undefined) {
+   return;
+  }
+  controller._byobRequest._associatedReadableByteStreamController = undefined;
+  controller._byobRequest._view = undefined;
+  controller._byobRequest = undefined;
+ }
+ function ReadableByteStreamControllerProcessPullIntoDescriptorsUsingQueue(controller) {
+  while (controller._pendingPullIntos.length > 0) {
+   if (controller._queueTotalSize === 0) {
+    return;
+   }
+   var pullIntoDescriptor = controller._pendingPullIntos.peek();
+   if (ReadableByteStreamControllerFillPullIntoDescriptorFromQueue(controller, pullIntoDescriptor) === true) {
+    ReadableByteStreamControllerShiftPendingPullInto(controller);
+    ReadableByteStreamControllerCommitPullIntoDescriptor(controller._controlledReadableByteStream, pullIntoDescriptor);
+   }
+  }
+ }
+ function ReadableByteStreamControllerPullInto(controller, view) {
+  var stream = controller._controlledReadableByteStream;
+  var elementSize = 1;
+  if (view.constructor !== DataView) {
+   elementSize = view.constructor.BYTES_PER_ELEMENT;
+  }
+  var ctor = view.constructor;
+  var buffer = TransferArrayBuffer(view.buffer);
+  var pullIntoDescriptor = {
+   buffer: buffer,
+   byteOffset: view.byteOffset,
+   byteLength: view.byteLength,
+   bytesFilled: 0,
+   elementSize: elementSize,
+   ctor: ctor,
+   readerType: 'byob'
+  };
+  if (controller._pendingPullIntos.length > 0) {
+   controller._pendingPullIntos.push(pullIntoDescriptor);
+   return ReadableStreamAddReadIntoRequest(stream);
+  }
+  if (stream._state === 'closed') {
+   var emptyView = new ctor(pullIntoDescriptor.buffer, pullIntoDescriptor.byteOffset, 0);
+   return promiseResolvedWith(ReadableStreamCreateReadResult(emptyView, true, stream._reader._forAuthorCode));
+  }
+  if (controller._queueTotalSize > 0) {
+   if (ReadableByteStreamControllerFillPullIntoDescriptorFromQueue(controller, pullIntoDescriptor) === true) {
+    var filledView = ReadableByteStreamControllerConvertPullIntoDescriptor(pullIntoDescriptor);
+    ReadableByteStreamControllerHandleQueueDrain(controller);
+    return promiseResolvedWith(ReadableStreamCreateReadResult(filledView, false, stream._reader._forAuthorCode));
+   }
+   if (controller._closeRequested === true) {
+    var e = new TypeError('Insufficient bytes to fill elements in the given buffer');
+    ReadableByteStreamControllerError(controller, e);
+    return promiseRejectedWith(e);
+   }
+  }
+  controller._pendingPullIntos.push(pullIntoDescriptor);
+  var promise = ReadableStreamAddReadIntoRequest(stream);
+  ReadableByteStreamControllerCallPullIfNeeded(controller);
+  return promise;
+ }
+ function ReadableByteStreamControllerRespondInClosedState(controller, firstDescriptor) {
+  firstDescriptor.buffer = TransferArrayBuffer(firstDescriptor.buffer);
+  var stream = controller._controlledReadableByteStream;
+  if (ReadableStreamHasBYOBReader(stream) === true) {
+   while (ReadableStreamGetNumReadIntoRequests(stream) > 0) {
+    var pullIntoDescriptor = ReadableByteStreamControllerShiftPendingPullInto(controller);
+    ReadableByteStreamControllerCommitPullIntoDescriptor(stream, pullIntoDescriptor);
+   }
+  }
+ }
+ function ReadableByteStreamControllerRespondInReadableState(controller, bytesWritten, pullIntoDescriptor) {
+  if (pullIntoDescriptor.bytesFilled + bytesWritten > pullIntoDescriptor.byteLength) {
+   throw new RangeError('bytesWritten out of range');
+  }
+  ReadableByteStreamControllerFillHeadPullIntoDescriptor(controller, bytesWritten, pullIntoDescriptor);
+  if (pullIntoDescriptor.bytesFilled < pullIntoDescriptor.elementSize) {
+   return;
+  }
+  ReadableByteStreamControllerShiftPendingPullInto(controller);
+  var remainderSize = pullIntoDescriptor.bytesFilled % pullIntoDescriptor.elementSize;
+  if (remainderSize > 0) {
+   var end = pullIntoDescriptor.byteOffset + pullIntoDescriptor.bytesFilled;
+   var remainder = pullIntoDescriptor.buffer.slice(end - remainderSize, end);
+   ReadableByteStreamControllerEnqueueChunkToQueue(controller, remainder, 0, remainder.byteLength);
+  }
+  pullIntoDescriptor.buffer = TransferArrayBuffer(pullIntoDescriptor.buffer);
+  pullIntoDescriptor.bytesFilled -= remainderSize;
+  ReadableByteStreamControllerCommitPullIntoDescriptor(controller._controlledReadableByteStream, pullIntoDescriptor);
+  ReadableByteStreamControllerProcessPullIntoDescriptorsUsingQueue(controller);
+ }
+ function ReadableByteStreamControllerRespondInternal(controller, bytesWritten) {
+  var firstDescriptor = controller._pendingPullIntos.peek();
+  var stream = controller._controlledReadableByteStream;
+  if (stream._state === 'closed') {
+   if (bytesWritten !== 0) {
+    throw new TypeError('bytesWritten must be 0 when calling respond() on a closed stream');
+   }
+   ReadableByteStreamControllerRespondInClosedState(controller, firstDescriptor);
+  } else {
+   ReadableByteStreamControllerRespondInReadableState(controller, bytesWritten, firstDescriptor);
+  }
+  ReadableByteStreamControllerCallPullIfNeeded(controller);
+ }
+ function ReadableByteStreamControllerShiftPendingPullInto(controller) {
+  var descriptor = controller._pendingPullIntos.shift();
+  ReadableByteStreamControllerInvalidateBYOBRequest(controller);
+  return descriptor;
+ }
+ function ReadableByteStreamControllerShouldCallPull(controller) {
+  var stream = controller._controlledReadableByteStream;
+  if (stream._state !== 'readable') {
+   return false;
+  }
+  if (controller._closeRequested === true) {
+   return false;
+  }
+  if (controller._started === false) {
+   return false;
+  }
+  if (ReadableStreamHasDefaultReader(stream) === true && ReadableStreamGetNumReadRequests(stream) > 0) {
+   return true;
+  }
+  if (ReadableStreamHasBYOBReader(stream) === true && ReadableStreamGetNumReadIntoRequests(stream) > 0) {
+   return true;
+  }
+  var desiredSize = ReadableByteStreamControllerGetDesiredSize(controller);
+  if (desiredSize > 0) {
+   return true;
+  }
+  return false;
+ }
+ function ReadableByteStreamControllerClearAlgorithms(controller) {
+  controller._pullAlgorithm = undefined;
+  controller._cancelAlgorithm = undefined;
+ }
+ function ReadableByteStreamControllerClose(controller) {
+  var stream = controller._controlledReadableByteStream;
+  if (controller._queueTotalSize > 0) {
+   controller._closeRequested = true;
+   return;
+  }
+  if (controller._pendingPullIntos.length > 0) {
+   var firstPendingPullInto = controller._pendingPullIntos.peek();
+   if (firstPendingPullInto.bytesFilled > 0) {
+    var e = new TypeError('Insufficient bytes to fill elements in the given buffer');
+    ReadableByteStreamControllerError(controller, e);
+    throw e;
+   }
+  }
+  ReadableByteStreamControllerClearAlgorithms(controller);
+  ReadableStreamClose(stream);
+ }
+ function ReadableByteStreamControllerEnqueue(controller, chunk) {
+  var stream = controller._controlledReadableByteStream;
+  var buffer = chunk.buffer;
+  var byteOffset = chunk.byteOffset;
+  var byteLength = chunk.byteLength;
+  var transferredBuffer = TransferArrayBuffer(buffer);
+  if (ReadableStreamHasDefaultReader(stream) === true) {
+   if (ReadableStreamGetNumReadRequests(stream) === 0) {
+    ReadableByteStreamControllerEnqueueChunkToQueue(controller, transferredBuffer, byteOffset, byteLength);
+   } else {
+    var transferredView = new Uint8Array(transferredBuffer, byteOffset, byteLength);
+    ReadableStreamFulfillReadRequest(stream, transferredView, false);
+   }
+  } else if (ReadableStreamHasBYOBReader(stream) === true) {
+   ReadableByteStreamControllerEnqueueChunkToQueue(controller, transferredBuffer, byteOffset, byteLength);
+   ReadableByteStreamControllerProcessPullIntoDescriptorsUsingQueue(controller);
+  } else {
+   ReadableByteStreamControllerEnqueueChunkToQueue(controller, transferredBuffer, byteOffset, byteLength);
+  }
+  ReadableByteStreamControllerCallPullIfNeeded(controller);
+ }
+ function ReadableByteStreamControllerError(controller, e) {
+  var stream = controller._controlledReadableByteStream;
+  if (stream._state !== 'readable') {
+   return;
+  }
+  ReadableByteStreamControllerClearPendingPullIntos(controller);
+  ResetQueue(controller);
+  ReadableByteStreamControllerClearAlgorithms(controller);
+  ReadableStreamError(stream, e);
+ }
+ function ReadableByteStreamControllerGetDesiredSize(controller) {
+  var stream = controller._controlledReadableByteStream;
+  var state = stream._state;
+  if (state === 'errored') {
+   return null;
+  }
+  if (state === 'closed') {
+   return 0;
+  }
+  return controller._strategyHWM - controller._queueTotalSize;
+ }
+ function ReadableByteStreamControllerRespond(controller, bytesWritten) {
+  bytesWritten = Number(bytesWritten);
+  if (IsFiniteNonNegativeNumber(bytesWritten) === false) {
+   throw new RangeError('bytesWritten must be a finite');
+  }
+  ReadableByteStreamControllerRespondInternal(controller, bytesWritten);
+ }
+ function ReadableByteStreamControllerRespondWithNewView(controller, view) {
+  var firstDescriptor = controller._pendingPullIntos.peek();
+  if (firstDescriptor.byteOffset + firstDescriptor.bytesFilled !== view.byteOffset) {
+   throw new RangeError('The region specified by view does not match byobRequest');
+  }
+  if (firstDescriptor.byteLength !== view.byteLength) {
+   throw new RangeError('The buffer of view has different capacity than byobRequest');
+  }
+  firstDescriptor.buffer = view.buffer;
+  ReadableByteStreamControllerRespondInternal(controller, view.byteLength);
+ }
+ function SetUpReadableByteStreamController(stream, controller, startAlgorithm, pullAlgorithm, cancelAlgorithm, highWaterMark, autoAllocateChunkSize) {
+  controller._controlledReadableByteStream = stream;
+  controller._pullAgain = false;
+  controller._pulling = false;
+  controller._byobRequest = undefined;
+  controller._queue = controller._queueTotalSize = undefined;
+  ResetQueue(controller);
+  controller._closeRequested = false;
+  controller._started = false;
+  controller._strategyHWM = ValidateAndNormalizeHighWaterMark(highWaterMark);
+  controller._pullAlgorithm = pullAlgorithm;
+  controller._cancelAlgorithm = cancelAlgorithm;
+  controller._autoAllocateChunkSize = autoAllocateChunkSize;
+  controller._pendingPullIntos = new SimpleQueue();
+  stream._readableStreamController = controller;
+  var startResult = startAlgorithm();
+  uponPromise(promiseResolvedWith(startResult), function () {
+   controller._started = true;
+   ReadableByteStreamControllerCallPullIfNeeded(controller);
+  }, function (r) {
+   ReadableByteStreamControllerError(controller, r);
+  });
+ }
+ function SetUpReadableByteStreamControllerFromUnderlyingSource(stream, underlyingByteSource, highWaterMark) {
+  var controller = Object.create(ReadableByteStreamController.prototype);
+  function startAlgorithm() {
+   return InvokeOrNoop(underlyingByteSource, 'start', [controller]);
+  }
+  var pullAlgorithm = CreateAlgorithmFromUnderlyingMethod(underlyingByteSource, 'pull', 0, [controller]);
+  var cancelAlgorithm = CreateAlgorithmFromUnderlyingMethod(underlyingByteSource, 'cancel', 1, []);
+  var autoAllocateChunkSize = underlyingByteSource.autoAllocateChunkSize;
+  if (autoAllocateChunkSize !== undefined) {
+   autoAllocateChunkSize = Number(autoAllocateChunkSize);
+   if (NumberIsInteger(autoAllocateChunkSize) === false || autoAllocateChunkSize <= 0) {
+    throw new RangeError('autoAllocateChunkSize must be a positive integer');
+   }
+  }
+  SetUpReadableByteStreamController(stream, controller, startAlgorithm, pullAlgorithm, cancelAlgorithm, highWaterMark, autoAllocateChunkSize);
+ }
+ function SetUpReadableStreamBYOBRequest(request, controller, view) {
+  request._associatedReadableByteStreamController = controller;
+  request._view = view;
+ }
+ function byobRequestBrandCheckException(name) {
+  return new TypeError("ReadableStreamBYOBRequest.prototype." + name + " can only be used on a ReadableStreamBYOBRequest");
+ }
+ function byteStreamControllerBrandCheckException(name) {
+  return new TypeError("ReadableByteStreamController.prototype." + name + " can only be used on a ReadableByteStreamController");
+ }
+ function AcquireReadableStreamBYOBReader(stream, forAuthorCode) {
+  if (forAuthorCode === void 0) {
+   forAuthorCode = false;
+  }
+  var reader = new ReadableStreamBYOBReader(stream);
+  reader._forAuthorCode = forAuthorCode;
+  return reader;
+ }
+ function ReadableStreamAddReadIntoRequest(stream) {
+  var promise = newPromise(function (resolve, reject) {
+   var readIntoRequest = {
+    _resolve: resolve,
+    _reject: reject
+   };
+   stream._reader._readIntoRequests.push(readIntoRequest);
+  });
+  return promise;
+ }
+ function ReadableStreamFulfillReadIntoRequest(stream, chunk, done) {
+  var reader = stream._reader;
+  var readIntoRequest = reader._readIntoRequests.shift();
+  readIntoRequest._resolve(ReadableStreamCreateReadResult(chunk, done, reader._forAuthorCode));
+ }
+ function ReadableStreamGetNumReadIntoRequests(stream) {
+  return stream._reader._readIntoRequests.length;
+ }
+ function ReadableStreamHasBYOBReader(stream) {
+  var reader = stream._reader;
+  if (reader === undefined) {
+   return false;
+  }
+  if (!IsReadableStreamBYOBReader(reader)) {
+   return false;
+  }
+  return true;
+ }
+ var ReadableStreamBYOBReader = function () {
+  function ReadableStreamBYOBReader(stream) {
+   if (!IsReadableStream(stream)) {
+    throw new TypeError('ReadableStreamBYOBReader can only be constructed with a ReadableStream instance given a ' + 'byte source');
+   }
+   if (IsReadableByteStreamController(stream._readableStreamController) === false) {
+    throw new TypeError('Cannot construct a ReadableStreamBYOBReader for a stream not constructed with a byte ' + 'source');
+   }
+   if (IsReadableStreamLocked(stream)) {
+    throw new TypeError('This stream has already been locked for exclusive reading by another reader');
+   }
+   ReadableStreamReaderGenericInitialize(this, stream);
+   this._readIntoRequests = new SimpleQueue();
+  }
+  Object.defineProperty(ReadableStreamBYOBReader.prototype, "closed", {
+   get: function () {
+    if (!IsReadableStreamBYOBReader(this)) {
+     return promiseRejectedWith(byobReaderBrandCheckException('closed'));
+    }
+    return this._closedPromise;
+   },
+   enumerable: true,
+   configurable: true
+  });
+  ReadableStreamBYOBReader.prototype.cancel = function (reason) {
+   if (!IsReadableStreamBYOBReader(this)) {
+    return promiseRejectedWith(byobReaderBrandCheckException('cancel'));
+   }
+   if (this._ownerReadableStream === undefined) {
+    return promiseRejectedWith(readerLockException('cancel'));
+   }
+   return ReadableStreamReaderGenericCancel(this, reason);
+  };
+  ReadableStreamBYOBReader.prototype.read = function (view) {
+   if (!IsReadableStreamBYOBReader(this)) {
+    return promiseRejectedWith(byobReaderBrandCheckException('read'));
+   }
+   if (this._ownerReadableStream === undefined) {
+    return promiseRejectedWith(readerLockException('read from'));
+   }
+   if (!ArrayBuffer.isView(view)) {
+    return promiseRejectedWith(new TypeError('view must be an array buffer view'));
+   }
+   if (IsDetachedBuffer(view.buffer) === true);
+   if (view.byteLength === 0) {
+    return promiseRejectedWith(new TypeError('view must have non-zero byteLength'));
+   }
+   return ReadableStreamBYOBReaderRead(this, view);
+  };
+  ReadableStreamBYOBReader.prototype.releaseLock = function () {
+   if (!IsReadableStreamBYOBReader(this)) {
+    throw byobReaderBrandCheckException('releaseLock');
+   }
+   if (this._ownerReadableStream === undefined) {
+    return;
+   }
+   if (this._readIntoRequests.length > 0) {
+    throw new TypeError('Tried to release a reader lock when that reader has pending read() calls un-settled');
+   }
+   ReadableStreamReaderGenericRelease(this);
+  };
+  return ReadableStreamBYOBReader;
+ }();
+ function IsReadableStreamBYOBReader(x) {
+  if (!typeIsObject(x)) {
+   return false;
+  }
+  if (!Object.prototype.hasOwnProperty.call(x, '_readIntoRequests')) {
+   return false;
+  }
+  return true;
+ }
+ function ReadableStreamBYOBReaderRead(reader, view) {
+  var stream = reader._ownerReadableStream;
+  stream._disturbed = true;
+  if (stream._state === 'errored') {
+   return promiseRejectedWith(stream._storedError);
+  }
+  return ReadableByteStreamControllerPullInto(stream._readableStreamController, view);
+ }
+ function byobReaderBrandCheckException(name) {
+  return new TypeError("ReadableStreamBYOBReader.prototype." + name + " can only be used on a ReadableStreamBYOBReader");
+ }
+ var ReadableStream = function () {
+  function ReadableStream(underlyingSource, strategy) {
+   if (underlyingSource === void 0) {
+    underlyingSource = {};
+   }
+   if (strategy === void 0) {
+    strategy = {};
+   }
+   InitializeReadableStream(this);
+   var size = strategy.size;
+   var highWaterMark = strategy.highWaterMark;
+   var type = underlyingSource.type;
+   var typeString = String(type);
+   if (typeString === 'bytes') {
+    if (size !== undefined) {
+     throw new RangeError('The strategy for a byte stream cannot have a size function');
+    }
+    if (highWaterMark === undefined) {
+     highWaterMark = 0;
+    }
+    highWaterMark = ValidateAndNormalizeHighWaterMark(highWaterMark);
+    SetUpReadableByteStreamControllerFromUnderlyingSource(this, underlyingSource, highWaterMark);
+   } else if (type === undefined) {
+    var sizeAlgorithm = MakeSizeAlgorithmFromSizeFunction(size);
+    if (highWaterMark === undefined) {
+     highWaterMark = 1;
+    }
+    highWaterMark = ValidateAndNormalizeHighWaterMark(highWaterMark);
+    SetUpReadableStreamDefaultControllerFromUnderlyingSource(this, underlyingSource, highWaterMark, sizeAlgorithm);
+   } else {
+    throw new RangeError('Invalid type is specified');
+   }
+  }
+  Object.defineProperty(ReadableStream.prototype, "locked", {
+   get: function () {
+    if (IsReadableStream(this) === false) {
+     throw streamBrandCheckException$1('locked');
+    }
+    return IsReadableStreamLocked(this);
+   },
+   enumerable: true,
+   configurable: true
+  });
+  ReadableStream.prototype.cancel = function (reason) {
+   if (IsReadableStream(this) === false) {
+    return promiseRejectedWith(streamBrandCheckException$1('cancel'));
+   }
+   if (IsReadableStreamLocked(this) === true) {
+    return promiseRejectedWith(new TypeError('Cannot cancel a stream that already has a reader'));
+   }
+   return ReadableStreamCancel(this, reason);
+  };
+  ReadableStream.prototype.getReader = function (_a) {
+   var mode = (_a === void 0 ? {} : _a).mode;
+   if (IsReadableStream(this) === false) {
+    throw streamBrandCheckException$1('getReader');
+   }
+   if (mode === undefined) {
+    return AcquireReadableStreamDefaultReader(this, true);
+   }
+   mode = String(mode);
+   if (mode === 'byob') {
+    return AcquireReadableStreamBYOBReader(this, true);
+   }
+   throw new RangeError('Invalid mode is specified');
+  };
+  ReadableStream.prototype.pipeThrough = function (_a, _b) {
+   var writable = _a.writable, readable = _a.readable;
+   var _c = _b === void 0 ? {} : _b, preventClose = _c.preventClose, preventAbort = _c.preventAbort, preventCancel = _c.preventCancel, signal = _c.signal;
+   if (IsReadableStream(this) === false) {
+    throw streamBrandCheckException$1('pipeThrough');
+   }
+   if (IsWritableStream(writable) === false) {
+    throw new TypeError('writable argument to pipeThrough must be a WritableStream');
+   }
+   if (IsReadableStream(readable) === false) {
+    throw new TypeError('readable argument to pipeThrough must be a ReadableStream');
+   }
+   preventClose = Boolean(preventClose);
+   preventAbort = Boolean(preventAbort);
+   preventCancel = Boolean(preventCancel);
+   if (signal !== undefined && !isAbortSignal(signal)) {
+    throw new TypeError('ReadableStream.prototype.pipeThrough\'s signal option must be an AbortSignal');
+   }
+   if (IsReadableStreamLocked(this) === true) {
+    throw new TypeError('ReadableStream.prototype.pipeThrough cannot be used on a locked ReadableStream');
+   }
+   if (IsWritableStreamLocked(writable) === true) {
+    throw new TypeError('ReadableStream.prototype.pipeThrough cannot be used on a locked WritableStream');
+   }
+   var promise = ReadableStreamPipeTo(this, writable, preventClose, preventAbort, preventCancel, signal);
+   setPromiseIsHandledToTrue(promise);
+   return readable;
+  };
+  ReadableStream.prototype.pipeTo = function (dest, _a) {
+   var _b = _a === void 0 ? {} : _a, preventClose = _b.preventClose, preventAbort = _b.preventAbort, preventCancel = _b.preventCancel, signal = _b.signal;
+   if (IsReadableStream(this) === false) {
+    return promiseRejectedWith(streamBrandCheckException$1('pipeTo'));
+   }
+   if (IsWritableStream(dest) === false) {
+    return promiseRejectedWith(new TypeError('ReadableStream.prototype.pipeTo\'s first argument must be a WritableStream'));
+   }
+   preventClose = Boolean(preventClose);
+   preventAbort = Boolean(preventAbort);
+   preventCancel = Boolean(preventCancel);
+   if (signal !== undefined && !isAbortSignal(signal)) {
+    return promiseRejectedWith(new TypeError('ReadableStream.prototype.pipeTo\'s signal option must be an AbortSignal'));
+   }
+   if (IsReadableStreamLocked(this) === true) {
+    return promiseRejectedWith(new TypeError('ReadableStream.prototype.pipeTo cannot be used on a locked ReadableStream'));
+   }
+   if (IsWritableStreamLocked(dest) === true) {
+    return promiseRejectedWith(new TypeError('ReadableStream.prototype.pipeTo cannot be used on a locked WritableStream'));
+   }
+   return ReadableStreamPipeTo(this, dest, preventClose, preventAbort, preventCancel, signal);
+  };
+  ReadableStream.prototype.tee = function () {
+   if (IsReadableStream(this) === false) {
+    throw streamBrandCheckException$1('tee');
+   }
+   var branches = ReadableStreamTee(this);
+   return createArrayFromList(branches);
+  };
+  ReadableStream.prototype.getIterator = function (_a) {
+   var _b = (_a === void 0 ? {} : _a).preventCancel, preventCancel = _b === void 0 ? false : _b;
+   if (IsReadableStream(this) === false) {
+    throw streamBrandCheckException$1('getIterator');
+   }
+   return AcquireReadableStreamAsyncIterator(this, preventCancel);
+  };
+  return ReadableStream;
+ }();
+ if (typeof SymbolPolyfill.asyncIterator === 'symbol') {
+  Object.defineProperty(ReadableStream.prototype, SymbolPolyfill.asyncIterator, {
+   value: ReadableStream.prototype.getIterator,
+   enumerable: false,
+   writable: true,
+   configurable: true
+  });
+ }
+ function CreateReadableStream(startAlgorithm, pullAlgorithm, cancelAlgorithm, highWaterMark, sizeAlgorithm) {
+  if (highWaterMark === void 0) {
+   highWaterMark = 1;
+  }
+  if (sizeAlgorithm === void 0) {
+   sizeAlgorithm = function () {
+    return 1;
+   };
+  }
+  var stream = Object.create(ReadableStream.prototype);
+  InitializeReadableStream(stream);
+  var controller = Object.create(ReadableStreamDefaultController.prototype);
+  SetUpReadableStreamDefaultController(stream, controller, startAlgorithm, pullAlgorithm, cancelAlgorithm, highWaterMark, sizeAlgorithm);
+  return stream;
+ }
+ function InitializeReadableStream(stream) {
+  stream._state = 'readable';
+  stream._reader = undefined;
+  stream._storedError = undefined;
+  stream._disturbed = false;
+ }
+ function IsReadableStream(x) {
+  if (!typeIsObject(x)) {
+   return false;
+  }
+  if (!Object.prototype.hasOwnProperty.call(x, '_readableStreamController')) {
+   return false;
+  }
+  return true;
+ }
+ function IsReadableStreamLocked(stream) {
+  if (stream._reader === undefined) {
+   return false;
+  }
+  return true;
+ }
+ function ReadableStreamCancel(stream, reason) {
+  stream._disturbed = true;
+  if (stream._state === 'closed') {
+   return promiseResolvedWith(undefined);
+  }
+  if (stream._state === 'errored') {
+   return promiseRejectedWith(stream._storedError);
+  }
+  ReadableStreamClose(stream);
+  var sourceCancelPromise = stream._readableStreamController[CancelSteps](reason);
+  return transformPromiseWith(sourceCancelPromise, noop);
+ }
+ function ReadableStreamClose(stream) {
+  stream._state = 'closed';
+  var reader = stream._reader;
+  if (reader === undefined) {
+   return;
+  }
+  if (IsReadableStreamDefaultReader(reader)) {
+   reader._readRequests.forEach(function (readRequest) {
+    readRequest._resolve(ReadableStreamCreateReadResult(undefined, true, reader._forAuthorCode));
+   });
+   reader._readRequests = new SimpleQueue();
+  }
+  defaultReaderClosedPromiseResolve(reader);
+ }
+ function ReadableStreamError(stream, e) {
+  stream._state = 'errored';
+  stream._storedError = e;
+  var reader = stream._reader;
+  if (reader === undefined) {
+   return;
+  }
+  if (IsReadableStreamDefaultReader(reader)) {
+   reader._readRequests.forEach(function (readRequest) {
+    readRequest._reject(e);
+   });
+   reader._readRequests = new SimpleQueue();
+  } else {
+   reader._readIntoRequests.forEach(function (readIntoRequest) {
+    readIntoRequest._reject(e);
+   });
+   reader._readIntoRequests = new SimpleQueue();
+  }
+  defaultReaderClosedPromiseReject(reader, e);
+ }
+ function streamBrandCheckException$1(name) {
+  return new TypeError("ReadableStream.prototype." + name + " can only be used on a ReadableStream");
+ }
+ var ByteLengthQueuingStrategy = function () {
+  function ByteLengthQueuingStrategy(_a) {
+   var highWaterMark = _a.highWaterMark;
+   this.highWaterMark = highWaterMark;
+  }
+  ByteLengthQueuingStrategy.prototype.size = function (chunk) {
+   return chunk.byteLength;
+  };
+  return ByteLengthQueuingStrategy;
+ }();
+ var CountQueuingStrategy = function () {
+  function CountQueuingStrategy(_a) {
+   var highWaterMark = _a.highWaterMark;
+   this.highWaterMark = highWaterMark;
+  }
+  CountQueuingStrategy.prototype.size = function () {
+   return 1;
+  };
+  return CountQueuingStrategy;
+ }();
+ var TransformStream = function () {
+  function TransformStream(transformer, writableStrategy, readableStrategy) {
+   if (transformer === void 0) {
+    transformer = {};
+   }
+   if (writableStrategy === void 0) {
+    writableStrategy = {};
+   }
+   if (readableStrategy === void 0) {
+    readableStrategy = {};
+   }
+   var writableSizeFunction = writableStrategy.size;
+   var writableHighWaterMark = writableStrategy.highWaterMark;
+   var readableSizeFunction = readableStrategy.size;
+   var readableHighWaterMark = readableStrategy.highWaterMark;
+   var writableType = transformer.writableType;
+   if (writableType !== undefined) {
+    throw new RangeError('Invalid writable type specified');
+   }
+   var writableSizeAlgorithm = MakeSizeAlgorithmFromSizeFunction(writableSizeFunction);
+   if (writableHighWaterMark === undefined) {
+    writableHighWaterMark = 1;
+   }
+   writableHighWaterMark = ValidateAndNormalizeHighWaterMark(writableHighWaterMark);
+   var readableType = transformer.readableType;
+   if (readableType !== undefined) {
+    throw new RangeError('Invalid readable type specified');
+   }
+   var readableSizeAlgorithm = MakeSizeAlgorithmFromSizeFunction(readableSizeFunction);
+   if (readableHighWaterMark === undefined) {
+    readableHighWaterMark = 0;
+   }
+   readableHighWaterMark = ValidateAndNormalizeHighWaterMark(readableHighWaterMark);
+   var startPromise_resolve;
+   var startPromise = newPromise(function (resolve) {
+    startPromise_resolve = resolve;
+   });
+   InitializeTransformStream(this, startPromise, writableHighWaterMark, writableSizeAlgorithm, readableHighWaterMark, readableSizeAlgorithm);
+   SetUpTransformStreamDefaultControllerFromTransformer(this, transformer);
+   var startResult = InvokeOrNoop(transformer, 'start', [this._transformStreamController]);
+   startPromise_resolve(startResult);
+  }
+  Object.defineProperty(TransformStream.prototype, "readable", {
+   get: function () {
+    if (IsTransformStream(this) === false) {
+     throw streamBrandCheckException$2('readable');
+    }
+    return this._readable;
+   },
+   enumerable: true,
+   configurable: true
+  });
+  Object.defineProperty(TransformStream.prototype, "writable", {
+   get: function () {
+    if (IsTransformStream(this) === false) {
+     throw streamBrandCheckException$2('writable');
+    }
+    return this._writable;
+   },
+   enumerable: true,
+   configurable: true
+  });
+  return TransformStream;
+ }();
+ function InitializeTransformStream(stream, startPromise, writableHighWaterMark, writableSizeAlgorithm, readableHighWaterMark, readableSizeAlgorithm) {
+  function startAlgorithm() {
+   return startPromise;
+  }
+  function writeAlgorithm(chunk) {
+   return TransformStreamDefaultSinkWriteAlgorithm(stream, chunk);
+  }
+  function abortAlgorithm(reason) {
+   return TransformStreamDefaultSinkAbortAlgorithm(stream, reason);
+  }
+  function closeAlgorithm() {
+   return TransformStreamDefaultSinkCloseAlgorithm(stream);
+  }
+  stream._writable = CreateWritableStream(startAlgorithm, writeAlgorithm, closeAlgorithm, abortAlgorithm, writableHighWaterMark, writableSizeAlgorithm);
+  function pullAlgorithm() {
+   return TransformStreamDefaultSourcePullAlgorithm(stream);
+  }
+  function cancelAlgorithm(reason) {
+   TransformStreamErrorWritableAndUnblockWrite(stream, reason);
+   return promiseResolvedWith(undefined);
+  }
+  stream._readable = CreateReadableStream(startAlgorithm, pullAlgorithm, cancelAlgorithm, readableHighWaterMark, readableSizeAlgorithm);
+  stream._backpressure = undefined;
+  stream._backpressureChangePromise = undefined;
+  stream._backpressureChangePromise_resolve = undefined;
+  TransformStreamSetBackpressure(stream, true);
+  stream._transformStreamController = undefined;
+ }
+ function IsTransformStream(x) {
+  if (!typeIsObject(x)) {
+   return false;
+  }
+  if (!Object.prototype.hasOwnProperty.call(x, '_transformStreamController')) {
+   return false;
+  }
+  return true;
+ }
+ function TransformStreamError(stream, e) {
+  ReadableStreamDefaultControllerError(stream._readable._readableStreamController, e);
+  TransformStreamErrorWritableAndUnblockWrite(stream, e);
+ }
+ function TransformStreamErrorWritableAndUnblockWrite(stream, e) {
+  TransformStreamDefaultControllerClearAlgorithms(stream._transformStreamController);
+  WritableStreamDefaultControllerErrorIfNeeded(stream._writable._writableStreamController, e);
+  if (stream._backpressure === true) {
+   TransformStreamSetBackpressure(stream, false);
+  }
+ }
+ function TransformStreamSetBackpressure(stream, backpressure) {
+  if (stream._backpressureChangePromise !== undefined) {
+   stream._backpressureChangePromise_resolve();
+  }
+  stream._backpressureChangePromise = newPromise(function (resolve) {
+   stream._backpressureChangePromise_resolve = resolve;
+  });
+  stream._backpressure = backpressure;
+ }
+ var TransformStreamDefaultController = function () {
+  function TransformStreamDefaultController() {
+   throw new TypeError('TransformStreamDefaultController instances cannot be created directly');
+  }
+  Object.defineProperty(TransformStreamDefaultController.prototype, "desiredSize", {
+   get: function () {
+    if (IsTransformStreamDefaultController(this) === false) {
+     throw defaultControllerBrandCheckException$1('desiredSize');
+    }
+    var readableController = this._controlledTransformStream._readable._readableStreamController;
+    return ReadableStreamDefaultControllerGetDesiredSize(readableController);
+   },
+   enumerable: true,
+   configurable: true
+  });
+  TransformStreamDefaultController.prototype.enqueue = function (chunk) {
+   if (IsTransformStreamDefaultController(this) === false) {
+    throw defaultControllerBrandCheckException$1('enqueue');
+   }
+   TransformStreamDefaultControllerEnqueue(this, chunk);
+  };
+  TransformStreamDefaultController.prototype.error = function (reason) {
+   if (IsTransformStreamDefaultController(this) === false) {
+    throw defaultControllerBrandCheckException$1('error');
+   }
+   TransformStreamDefaultControllerError(this, reason);
+  };
+  TransformStreamDefaultController.prototype.terminate = function () {
+   if (IsTransformStreamDefaultController(this) === false) {
+    throw defaultControllerBrandCheckException$1('terminate');
+   }
+   TransformStreamDefaultControllerTerminate(this);
+  };
+  return TransformStreamDefaultController;
+ }();
+ function IsTransformStreamDefaultController(x) {
+  if (!typeIsObject(x)) {
+   return false;
+  }
+  if (!Object.prototype.hasOwnProperty.call(x, '_controlledTransformStream')) {
+   return false;
+  }
+  return true;
+ }
+ function SetUpTransformStreamDefaultController(stream, controller, transformAlgorithm, flushAlgorithm) {
+  controller._controlledTransformStream = stream;
+  stream._transformStreamController = controller;
+  controller._transformAlgorithm = transformAlgorithm;
+  controller._flushAlgorithm = flushAlgorithm;
+ }
+ function SetUpTransformStreamDefaultControllerFromTransformer(stream, transformer) {
+  var controller = Object.create(TransformStreamDefaultController.prototype);
+  var transformAlgorithm = function (chunk) {
+   try {
+    TransformStreamDefaultControllerEnqueue(controller, chunk);
+    return promiseResolvedWith(undefined);
+   } catch (transformResultE) {
+    return promiseRejectedWith(transformResultE);
+   }
+  };
+  var transformMethod = transformer.transform;
+  if (transformMethod !== undefined) {
+   if (typeof transformMethod !== 'function') {
+    throw new TypeError('transform is not a method');
+   }
+   transformAlgorithm = function (chunk) {
+    return PromiseCall(transformMethod, transformer, [
+     chunk,
+     controller
+    ]);
+   };
+  }
+  var flushAlgorithm = CreateAlgorithmFromUnderlyingMethod(transformer, 'flush', 0, [controller]);
+  SetUpTransformStreamDefaultController(stream, controller, transformAlgorithm, flushAlgorithm);
+ }
+ function TransformStreamDefaultControllerClearAlgorithms(controller) {
+  controller._transformAlgorithm = undefined;
+  controller._flushAlgorithm = undefined;
+ }
+ function TransformStreamDefaultControllerEnqueue(controller, chunk) {
+  var stream = controller._controlledTransformStream;
+  var readableController = stream._readable._readableStreamController;
+  if (ReadableStreamDefaultControllerCanCloseOrEnqueue(readableController) === false) {
+   throw new TypeError('Readable side is not in a state that permits enqueue');
+  }
+  try {
+   ReadableStreamDefaultControllerEnqueue(readableController, chunk);
+  } catch (e) {
+   TransformStreamErrorWritableAndUnblockWrite(stream, e);
+   throw stream._readable._storedError;
+  }
+  var backpressure = ReadableStreamDefaultControllerHasBackpressure(readableController);
+  if (backpressure !== stream._backpressure) {
+   TransformStreamSetBackpressure(stream, true);
+  }
+ }
+ function TransformStreamDefaultControllerError(controller, e) {
+  TransformStreamError(controller._controlledTransformStream, e);
+ }
+ function TransformStreamDefaultControllerPerformTransform(controller, chunk) {
+  var transformPromise = controller._transformAlgorithm(chunk);
+  return transformPromiseWith(transformPromise, undefined, function (r) {
+   TransformStreamError(controller._controlledTransformStream, r);
+   throw r;
+  });
+ }
+ function TransformStreamDefaultControllerTerminate(controller) {
+  var stream = controller._controlledTransformStream;
+  var readableController = stream._readable._readableStreamController;
+  if (ReadableStreamDefaultControllerCanCloseOrEnqueue(readableController) === true) {
+   ReadableStreamDefaultControllerClose(readableController);
+  }
+  var error = new TypeError('TransformStream terminated');
+  TransformStreamErrorWritableAndUnblockWrite(stream, error);
+ }
+ function TransformStreamDefaultSinkWriteAlgorithm(stream, chunk) {
+  var controller = stream._transformStreamController;
+  if (stream._backpressure === true) {
+   var backpressureChangePromise = stream._backpressureChangePromise;
+   return transformPromiseWith(backpressureChangePromise, function () {
+    var writable = stream._writable;
+    var state = writable._state;
+    if (state === 'erroring') {
+     throw writable._storedError;
+    }
+    return TransformStreamDefaultControllerPerformTransform(controller, chunk);
+   });
+  }
+  return TransformStreamDefaultControllerPerformTransform(controller, chunk);
+ }
+ function TransformStreamDefaultSinkAbortAlgorithm(stream, reason) {
+  TransformStreamError(stream, reason);
+  return promiseResolvedWith(undefined);
+ }
+ function TransformStreamDefaultSinkCloseAlgorithm(stream) {
+  var readable = stream._readable;
+  var controller = stream._transformStreamController;
+  var flushPromise = controller._flushAlgorithm();
+  TransformStreamDefaultControllerClearAlgorithms(controller);
+  return transformPromiseWith(flushPromise, function () {
+   if (readable._state === 'errored') {
+    throw readable._storedError;
+   }
+   var readableController = readable._readableStreamController;
+   if (ReadableStreamDefaultControllerCanCloseOrEnqueue(readableController) === true) {
+    ReadableStreamDefaultControllerClose(readableController);
+   }
+  }, function (r) {
+   TransformStreamError(stream, r);
+   throw readable._storedError;
+  });
+ }
+ function TransformStreamDefaultSourcePullAlgorithm(stream) {
+  TransformStreamSetBackpressure(stream, false);
+  return stream._backpressureChangePromise;
+ }
+ function defaultControllerBrandCheckException$1(name) {
+  return new TypeError("TransformStreamDefaultController.prototype." + name + " can only be used on a TransformStreamDefaultController");
+ }
+ function streamBrandCheckException$2(name) {
+  return new TypeError("TransformStream.prototype." + name + " can only be used on a TransformStream");
+ }
+ exports.ByteLengthQueuingStrategy = ByteLengthQueuingStrategy;
+ exports.CountQueuingStrategy = CountQueuingStrategy;
+ exports.ReadableStream = ReadableStream;
+ exports.TransformStream = TransformStream;
+ exports.WritableStream = WritableStream;
+ Object.defineProperty(exports, '__esModule', { value: true });
+}));
+
+/***/ }),
+/* 144 */
+/***/ (function(module, exports, __w_pdfjs_require__) {
+
+__w_pdfjs_require__(145);
+__w_pdfjs_require__(114);
+__w_pdfjs_require__(77);
+__w_pdfjs_require__(116);
+var path = __w_pdfjs_require__(43);
+module.exports = path.Map;
+
+/***/ }),
+/* 145 */
+/***/ (function(module, exports, __w_pdfjs_require__) {
+
+"use strict";
+
+var collection = __w_pdfjs_require__(146);
+var collectionStrong = __w_pdfjs_require__(150);
+module.exports = collection('Map', function (init) {
+ return function Map() {
+  return init(this, arguments.length ? arguments[0] : undefined);
+ };
+}, collectionStrong);
+
+/***/ }),
+/* 146 */
+/***/ (function(module, exports, __w_pdfjs_require__) {
+
+"use strict";
+
+var $ = __w_pdfjs_require__(10);
+var global = __w_pdfjs_require__(11);
+var isForced = __w_pdfjs_require__(52);
+var redefine = __w_pdfjs_require__(29);
+var InternalMetadataModule = __w_pdfjs_require__(147);
+var iterate = __w_pdfjs_require__(124);
+var anInstance = __w_pdfjs_require__(123);
+var isObject = __w_pdfjs_require__(22);
+var fails = __w_pdfjs_require__(14);
+var checkCorrectnessOfIteration = __w_pdfjs_require__(97);
+var setToStringTag = __w_pdfjs_require__(85);
+var inheritIfRequired = __w_pdfjs_require__(149);
+module.exports = function (CONSTRUCTOR_NAME, wrapper, common) {
+ var IS_MAP = CONSTRUCTOR_NAME.indexOf('Map') !== -1;
+ var IS_WEAK = CONSTRUCTOR_NAME.indexOf('Weak') !== -1;
+ var ADDER = IS_MAP ? 'set' : 'add';
+ var NativeConstructor = global[CONSTRUCTOR_NAME];
+ var NativePrototype = NativeConstructor && NativeConstructor.prototype;
+ var Constructor = NativeConstructor;
+ var exported = {};
+ var fixMethod = function (KEY) {
+  var nativeMethod = NativePrototype[KEY];
+  redefine(NativePrototype, KEY, KEY == 'add' ? function add(value) {
+   nativeMethod.call(this, value === 0 ? 0 : value);
+   return this;
+  } : KEY == 'delete' ? function (key) {
+   return IS_WEAK && !isObject(key) ? false : nativeMethod.call(this, key === 0 ? 0 : key);
+  } : KEY == 'get' ? function get(key) {
+   return IS_WEAK && !isObject(key) ? undefined : nativeMethod.call(this, key === 0 ? 0 : key);
+  } : KEY == 'has' ? function has(key) {
+   return IS_WEAK && !isObject(key) ? false : nativeMethod.call(this, key === 0 ? 0 : key);
+  } : function set(key, value) {
+   nativeMethod.call(this, key === 0 ? 0 : key, value);
+   return this;
+  });
+ };
+ if (isForced(CONSTRUCTOR_NAME, typeof NativeConstructor != 'function' || !(IS_WEAK || NativePrototype.forEach && !fails(function () {
+   new NativeConstructor().entries().next();
+  })))) {
+  Constructor = common.getConstructor(wrapper, CONSTRUCTOR_NAME, IS_MAP, ADDER);
+  InternalMetadataModule.REQUIRED = true;
+ } else if (isForced(CONSTRUCTOR_NAME, true)) {
+  var instance = new Constructor();
+  var HASNT_CHAINING = instance[ADDER](IS_WEAK ? {} : -0, 1) != instance;
+  var THROWS_ON_PRIMITIVES = fails(function () {
+   instance.has(1);
+  });
+  var ACCEPT_ITERABLES = checkCorrectnessOfIteration(function (iterable) {
+   new NativeConstructor(iterable);
+  });
+  var BUGGY_ZERO = !IS_WEAK && fails(function () {
+   var $instance = new NativeConstructor();
+   var index = 5;
+   while (index--)
+    $instance[ADDER](index, index);
+   return !$instance.has(-0);
+  });
+  if (!ACCEPT_ITERABLES) {
+   Constructor = wrapper(function (dummy, iterable) {
+    anInstance(dummy, Constructor, CONSTRUCTOR_NAME);
+    var that = inheritIfRequired(new NativeConstructor(), dummy, Constructor);
+    if (iterable != undefined)
+     iterate(iterable, that[ADDER], that, IS_MAP);
+    return that;
+   });
+   Constructor.prototype = NativePrototype;
+   NativePrototype.constructor = Constructor;
+  }
+  if (THROWS_ON_PRIMITIVES || BUGGY_ZERO) {
+   fixMethod('delete');
+   fixMethod('has');
+   IS_MAP && fixMethod('get');
+  }
+  if (BUGGY_ZERO || HASNT_CHAINING)
+   fixMethod(ADDER);
+  if (IS_WEAK && NativePrototype.clear)
+   delete NativePrototype.clear;
+ }
+ exported[CONSTRUCTOR_NAME] = Constructor;
+ $({
+  global: true,
+  forced: Constructor != NativeConstructor
+ }, exported);
+ setToStringTag(Constructor, CONSTRUCTOR_NAME);
+ if (!IS_WEAK)
+  common.setStrong(Constructor, CONSTRUCTOR_NAME, IS_MAP);
+ return Constructor;
+};
+
+/***/ }),
+/* 147 */
+/***/ (function(module, exports, __w_pdfjs_require__) {
+
+var hiddenKeys = __w_pdfjs_require__(39);
+var isObject = __w_pdfjs_require__(22);
+var has = __w_pdfjs_require__(23);
+var defineProperty = __w_pdfjs_require__(27).f;
+var uid = __w_pdfjs_require__(38);
+var FREEZING = __w_pdfjs_require__(148);
+var METADATA = uid('meta');
+var id = 0;
+var isExtensible = Object.isExtensible || function () {
+ return true;
+};
+var setMetadata = function (it) {
+ defineProperty(it, METADATA, {
+  value: {
+   objectID: 'O' + ++id,
+   weakData: {}
+  }
+ });
+};
+var fastKey = function (it, create) {
+ if (!isObject(it))
+  return typeof it == 'symbol' ? it : (typeof it == 'string' ? 'S' : 'P') + it;
+ if (!has(it, METADATA)) {
+  if (!isExtensible(it))
+   return 'F';
+  if (!create)
+   return 'E';
+  setMetadata(it);
+ }
+ return it[METADATA].objectID;
+};
+var getWeakData = function (it, create) {
+ if (!has(it, METADATA)) {
+  if (!isExtensible(it))
+   return true;
+  if (!create)
+   return false;
+  setMetadata(it);
+ }
+ return it[METADATA].weakData;
+};
+var onFreeze = function (it) {
+ if (FREEZING && meta.REQUIRED && isExtensible(it) && !has(it, METADATA))
+  setMetadata(it);
+ return it;
+};
+var meta = module.exports = {
+ REQUIRED: false,
+ fastKey: fastKey,
+ getWeakData: getWeakData,
+ onFreeze: onFreeze
+};
+hiddenKeys[METADATA] = true;
+
+/***/ }),
+/* 148 */
+/***/ (function(module, exports, __w_pdfjs_require__) {
+
+var fails = __w_pdfjs_require__(14);
+module.exports = !fails(function () {
+ return Object.isExtensible(Object.preventExtensions({}));
+});
+
+/***/ }),
+/* 149 */
+/***/ (function(module, exports, __w_pdfjs_require__) {
+
+var isObject = __w_pdfjs_require__(22);
+var setPrototypeOf = __w_pdfjs_require__(87);
+module.exports = function ($this, dummy, Wrapper) {
+ var NewTarget, NewTargetPrototype;
+ if (setPrototypeOf && typeof (NewTarget = dummy.constructor) == 'function' && NewTarget !== Wrapper && isObject(NewTargetPrototype = NewTarget.prototype) && NewTargetPrototype !== Wrapper.prototype)
+  setPrototypeOf($this, NewTargetPrototype);
+ return $this;
+};
+
+/***/ }),
+/* 150 */
+/***/ (function(module, exports, __w_pdfjs_require__) {
+
+"use strict";
+
+var defineProperty = __w_pdfjs_require__(27).f;
+var create = __w_pdfjs_require__(71);
+var redefineAll = __w_pdfjs_require__(121);
+var bind = __w_pdfjs_require__(62);
+var anInstance = __w_pdfjs_require__(123);
+var iterate = __w_pdfjs_require__(124);
+var defineIterator = __w_pdfjs_require__(79);
+var setSpecies = __w_pdfjs_require__(122);
+var DESCRIPTORS = __w_pdfjs_require__(13);
+var fastKey = __w_pdfjs_require__(147).fastKey;
+var InternalStateModule = __w_pdfjs_require__(33);
+var setInternalState = InternalStateModule.set;
+var internalStateGetterFor = InternalStateModule.getterFor;
+module.exports = {
+ getConstructor: function (wrapper, CONSTRUCTOR_NAME, IS_MAP, ADDER) {
+  var C = wrapper(function (that, iterable) {
+   anInstance(that, C, CONSTRUCTOR_NAME);
+   setInternalState(that, {
+    type: CONSTRUCTOR_NAME,
+    index: create(null),
+    first: undefined,
+    last: undefined,
+    size: 0
+   });
+   if (!DESCRIPTORS)
+    that.size = 0;
+   if (iterable != undefined)
+    iterate(iterable, that[ADDER], that, IS_MAP);
+  });
+  var getInternalState = internalStateGetterFor(CONSTRUCTOR_NAME);
+  var define = function (that, key, value) {
+   var state = getInternalState(that);
+   var entry = getEntry(that, key);
+   var previous, index;
+   if (entry) {
+    entry.value = value;
+   } else {
+    state.last = entry = {
+     index: index = fastKey(key, true),
+     key: key,
+     value: value,
+     previous: previous = state.last,
+     next: undefined,
+     removed: false
+    };
+    if (!state.first)
+     state.first = entry;
+    if (previous)
+     previous.next = entry;
+    if (DESCRIPTORS)
+     state.size++;
+    else
+     that.size++;
+    if (index !== 'F')
+     state.index[index] = entry;
+   }
+   return that;
+  };
+  var getEntry = function (that, key) {
+   var state = getInternalState(that);
+   var index = fastKey(key);
+   var entry;
+   if (index !== 'F')
+    return state.index[index];
+   for (entry = state.first; entry; entry = entry.next) {
+    if (entry.key == key)
+     return entry;
+   }
+  };
+  redefineAll(C.prototype, {
+   clear: function clear() {
+    var that = this;
+    var state = getInternalState(that);
+    var data = state.index;
+    var entry = state.first;
+    while (entry) {
+     entry.removed = true;
+     if (entry.previous)
+      entry.previous = entry.previous.next = undefined;
+     delete data[entry.index];
+     entry = entry.next;
+    }
+    state.first = state.last = undefined;
+    if (DESCRIPTORS)
+     state.size = 0;
+    else
+     that.size = 0;
+   },
+   'delete': function (key) {
+    var that = this;
+    var state = getInternalState(that);
+    var entry = getEntry(that, key);
+    if (entry) {
+     var next = entry.next;
+     var prev = entry.previous;
+     delete state.index[entry.index];
+     entry.removed = true;
+     if (prev)
+      prev.next = next;
+     if (next)
+      next.previous = prev;
+     if (state.first == entry)
+      state.first = next;
+     if (state.last == entry)
+      state.last = prev;
+     if (DESCRIPTORS)
+      state.size--;
+     else
+      that.size--;
+    }
+    return !!entry;
+   },
+   forEach: function forEach(callbackfn) {
+    var state = getInternalState(this);
+    var boundFunction = bind(callbackfn, arguments.length > 1 ? arguments[1] : undefined, 3);
+    var entry;
+    while (entry = entry ? entry.next : state.first) {
+     boundFunction(entry.value, entry.key, this);
+     while (entry && entry.removed)
+      entry = entry.previous;
+    }
+   },
+   has: function has(key) {
+    return !!getEntry(this, key);
+   }
+  });
+  redefineAll(C.prototype, IS_MAP ? {
+   get: function get(key) {
+    var entry = getEntry(this, key);
+    return entry && entry.value;
+   },
+   set: function set(key, value) {
+    return define(this, key === 0 ? 0 : key, value);
+   }
+  } : {
+   add: function add(value) {
+    return define(this, value = value === 0 ? 0 : value, value);
+   }
+  });
+  if (DESCRIPTORS)
+   defineProperty(C.prototype, 'size', {
+    get: function () {
+     return getInternalState(this).size;
+    }
+   });
+  return C;
+ },
+ setStrong: function (C, CONSTRUCTOR_NAME, IS_MAP) {
+  var ITERATOR_NAME = CONSTRUCTOR_NAME + ' Iterator';
+  var getInternalCollectionState = internalStateGetterFor(CONSTRUCTOR_NAME);
+  var getInternalIteratorState = internalStateGetterFor(ITERATOR_NAME);
+  defineIterator(C, CONSTRUCTOR_NAME, function (iterated, kind) {
+   setInternalState(this, {
+    type: ITERATOR_NAME,
+    target: iterated,
+    state: getInternalCollectionState(iterated),
+    kind: kind,
+    last: undefined
+   });
+  }, function () {
+   var state = getInternalIteratorState(this);
+   var kind = state.kind;
+   var entry = state.last;
+   while (entry && entry.removed)
+    entry = entry.previous;
+   if (!state.target || !(state.last = entry = entry ? entry.next : state.state.first)) {
+    state.target = undefined;
+    return {
+     value: undefined,
+     done: true
+    };
+   }
+   if (kind == 'keys')
+    return {
+     value: entry.key,
+     done: false
+    };
+   if (kind == 'values')
+    return {
+     value: entry.value,
+     done: false
+    };
+   return {
+    value: [
+     entry.key,
+     entry.value
+    ],
+    done: false
+   };
+  }, IS_MAP ? 'entries' : 'values', !IS_MAP, true);
+  setSpecies(CONSTRUCTOR_NAME);
+ }
+};
+
+/***/ }),
+/* 151 */
+/***/ (function(module, exports, __w_pdfjs_require__) {
+
+__w_pdfjs_require__(152);
+__w_pdfjs_require__(114);
+__w_pdfjs_require__(77);
+__w_pdfjs_require__(116);
+var path = __w_pdfjs_require__(43);
+module.exports = path.Set;
+
+/***/ }),
+/* 152 */
+/***/ (function(module, exports, __w_pdfjs_require__) {
+
+"use strict";
+
+var collection = __w_pdfjs_require__(146);
+var collectionStrong = __w_pdfjs_require__(150);
+module.exports = collection('Set', function (init) {
+ return function Set() {
+  return init(this, arguments.length ? arguments[0] : undefined);
+ };
+}, collectionStrong);
+
+/***/ }),
+/* 153 */
+/***/ (function(module, exports, __w_pdfjs_require__) {
+
+__w_pdfjs_require__(114);
+__w_pdfjs_require__(154);
+__w_pdfjs_require__(116);
+var path = __w_pdfjs_require__(43);
+module.exports = path.WeakMap;
+
+/***/ }),
+/* 154 */
+/***/ (function(module, exports, __w_pdfjs_require__) {
+
+"use strict";
+
+var global = __w_pdfjs_require__(11);
+var redefineAll = __w_pdfjs_require__(121);
+var InternalMetadataModule = __w_pdfjs_require__(147);
+var collection = __w_pdfjs_require__(146);
+var collectionWeak = __w_pdfjs_require__(155);
+var isObject = __w_pdfjs_require__(22);
+var enforceIternalState = __w_pdfjs_require__(33).enforce;
+var NATIVE_WEAK_MAP = __w_pdfjs_require__(34);
+var IS_IE11 = !global.ActiveXObject && 'ActiveXObject' in global;
+var isExtensible = Object.isExtensible;
+var InternalWeakMap;
+var wrapper = function (init) {
+ return function WeakMap() {
+  return init(this, arguments.length ? arguments[0] : undefined);
+ };
+};
+var $WeakMap = module.exports = collection('WeakMap', wrapper, collectionWeak);
+if (NATIVE_WEAK_MAP && IS_IE11) {
+ InternalWeakMap = collectionWeak.getConstructor(wrapper, 'WeakMap', true);
+ InternalMetadataModule.REQUIRED = true;
+ var WeakMapPrototype = $WeakMap.prototype;
+ var nativeDelete = WeakMapPrototype['delete'];
+ var nativeHas = WeakMapPrototype.has;
+ var nativeGet = WeakMapPrototype.get;
+ var nativeSet = WeakMapPrototype.set;
+ redefineAll(WeakMapPrototype, {
+  'delete': function (key) {
+   if (isObject(key) && !isExtensible(key)) {
+    var state = enforceIternalState(this);
+    if (!state.frozen)
+     state.frozen = new InternalWeakMap();
+    return nativeDelete.call(this, key) || state.frozen['delete'](key);
+   }
+   return nativeDelete.call(this, key);
+  },
+  has: function has(key) {
+   if (isObject(key) && !isExtensible(key)) {
+    var state = enforceIternalState(this);
+    if (!state.frozen)
+     state.frozen = new InternalWeakMap();
+    return nativeHas.call(this, key) || state.frozen.has(key);
+   }
+   return nativeHas.call(this, key);
+  },
+  get: function get(key) {
+   if (isObject(key) && !isExtensible(key)) {
+    var state = enforceIternalState(this);
+    if (!state.frozen)
+     state.frozen = new InternalWeakMap();
+    return nativeHas.call(this, key) ? nativeGet.call(this, key) : state.frozen.get(key);
+   }
+   return nativeGet.call(this, key);
+  },
+  set: function set(key, value) {
+   if (isObject(key) && !isExtensible(key)) {
+    var state = enforceIternalState(this);
+    if (!state.frozen)
+     state.frozen = new InternalWeakMap();
+    nativeHas.call(this, key) ? nativeSet.call(this, key, value) : state.frozen.set(key, value);
+   } else
+    nativeSet.call(this, key, value);
+   return this;
+  }
+ });
+}
+
+/***/ }),
+/* 155 */
+/***/ (function(module, exports, __w_pdfjs_require__) {
+
+"use strict";
+
+var redefineAll = __w_pdfjs_require__(121);
+var getWeakData = __w_pdfjs_require__(147).getWeakData;
+var anObject = __w_pdfjs_require__(28);
+var isObject = __w_pdfjs_require__(22);
+var anInstance = __w_pdfjs_require__(123);
+var iterate = __w_pdfjs_require__(124);
+var ArrayIterationModule = __w_pdfjs_require__(156);
+var $has = __w_pdfjs_require__(23);
+var InternalStateModule = __w_pdfjs_require__(33);
+var setInternalState = InternalStateModule.set;
+var internalStateGetterFor = InternalStateModule.getterFor;
+var find = ArrayIterationModule.find;
+var findIndex = ArrayIterationModule.findIndex;
+var id = 0;
+var uncaughtFrozenStore = function (store) {
+ return store.frozen || (store.frozen = new UncaughtFrozenStore());
+};
+var UncaughtFrozenStore = function () {
+ this.entries = [];
+};
+var findUncaughtFrozen = function (store, key) {
+ return find(store.entries, function (it) {
+  return it[0] === key;
+ });
+};
+UncaughtFrozenStore.prototype = {
+ get: function (key) {
+  var entry = findUncaughtFrozen(this, key);
+  if (entry)
+   return entry[1];
+ },
+ has: function (key) {
+  return !!findUncaughtFrozen(this, key);
+ },
+ set: function (key, value) {
+  var entry = findUncaughtFrozen(this, key);
+  if (entry)
+   entry[1] = value;
+  else
+   this.entries.push([
+    key,
+    value
+   ]);
+ },
+ 'delete': function (key) {
+  var index = findIndex(this.entries, function (it) {
+   return it[0] === key;
+  });
+  if (~index)
+   this.entries.splice(index, 1);
+  return !!~index;
+ }
+};
+module.exports = {
+ getConstructor: function (wrapper, CONSTRUCTOR_NAME, IS_MAP, ADDER) {
+  var C = wrapper(function (that, iterable) {
+   anInstance(that, C, CONSTRUCTOR_NAME);
+   setInternalState(that, {
+    type: CONSTRUCTOR_NAME,
+    id: id++,
+    frozen: undefined
+   });
+   if (iterable != undefined)
+    iterate(iterable, that[ADDER], that, IS_MAP);
+  });
+  var getInternalState = internalStateGetterFor(CONSTRUCTOR_NAME);
+  var define = function (that, key, value) {
+   var state = getInternalState(that);
+   var data = getWeakData(anObject(key), true);
+   if (data === true)
+    uncaughtFrozenStore(state).set(key, value);
+   else
+    data[state.id] = value;
+   return that;
+  };
+  redefineAll(C.prototype, {
+   'delete': function (key) {
+    var state = getInternalState(this);
+    if (!isObject(key))
+     return false;
+    var data = getWeakData(key);
+    if (data === true)
+     return uncaughtFrozenStore(state)['delete'](key);
+    return data && $has(data, state.id) && delete data[state.id];
+   },
+   has: function has(key) {
+    var state = getInternalState(this);
+    if (!isObject(key))
+     return false;
+    var data = getWeakData(key);
+    if (data === true)
+     return uncaughtFrozenStore(state).has(key);
+    return data && $has(data, state.id);
+   }
+  });
+  redefineAll(C.prototype, IS_MAP ? {
+   get: function get(key) {
+    var state = getInternalState(this);
+    if (isObject(key)) {
+     var data = getWeakData(key);
+     if (data === true)
+      return uncaughtFrozenStore(state).get(key);
+     return data ? data[state.id] : undefined;
+    }
+   },
+   set: function set(key, value) {
+    return define(this, key, value);
+   }
+  } : {
+   add: function add(value) {
+    return define(this, value, true);
+   }
+  });
+  return C;
+ }
+};
+
+/***/ }),
+/* 156 */
+/***/ (function(module, exports, __w_pdfjs_require__) {
+
+var bind = __w_pdfjs_require__(62);
+var IndexedObject = __w_pdfjs_require__(18);
+var toObject = __w_pdfjs_require__(83);
+var toLength = __w_pdfjs_require__(47);
+var arraySpeciesCreate = __w_pdfjs_require__(157);
+var push = [].push;
+var createMethod = function (TYPE) {
+ var IS_MAP = TYPE == 1;
+ var IS_FILTER = TYPE == 2;
+ var IS_SOME = TYPE == 3;
+ var IS_EVERY = TYPE == 4;
+ var IS_FIND_INDEX = TYPE == 6;
+ var NO_HOLES = TYPE == 5 || IS_FIND_INDEX;
+ return function ($this, callbackfn, that, specificCreate) {
+  var O = toObject($this);
+  var self = IndexedObject(O);
+  var boundFunction = bind(callbackfn, that, 3);
+  var length = toLength(self.length);
+  var index = 0;
+  var create = specificCreate || arraySpeciesCreate;
+  var target = IS_MAP ? create($this, length) : IS_FILTER ? create($this, 0) : undefined;
+  var value, result;
+  for (; length > index; index++)
+   if (NO_HOLES || index in self) {
+    value = self[index];
+    result = boundFunction(value, index, O);
+    if (TYPE) {
+     if (IS_MAP)
+      target[index] = result;
+     else if (result)
+      switch (TYPE) {
+      case 3:
+       return true;
+      case 5:
+       return value;
+      case 6:
+       return index;
+      case 2:
+       push.call(target, value);
+      }
+     else if (IS_EVERY)
+      return false;
+    }
+   }
+  return IS_FIND_INDEX ? -1 : IS_SOME || IS_EVERY ? IS_EVERY : target;
+ };
+};
+module.exports = {
+ forEach: createMethod(0),
+ map: createMethod(1),
+ filter: createMethod(2),
+ some: createMethod(3),
+ every: createMethod(4),
+ find: createMethod(5),
+ findIndex: createMethod(6)
+};
+
+/***/ }),
+/* 157 */
+/***/ (function(module, exports, __w_pdfjs_require__) {
+
+var isObject = __w_pdfjs_require__(22);
+var isArray = __w_pdfjs_require__(158);
+var wellKnownSymbol = __w_pdfjs_require__(57);
+var SPECIES = wellKnownSymbol('species');
+module.exports = function (originalArray, length) {
+ var C;
+ if (isArray(originalArray)) {
+  C = originalArray.constructor;
+  if (typeof C == 'function' && (C === Array || isArray(C.prototype)))
+   C = undefined;
+  else if (isObject(C)) {
+   C = C[SPECIES];
+   if (C === null)
+    C = undefined;
+  }
+ }
+ return new (C === undefined ? Array : C)(length === 0 ? 0 : length);
+};
+
+/***/ }),
+/* 158 */
+/***/ (function(module, exports, __w_pdfjs_require__) {
+
+var classof = __w_pdfjs_require__(19);
+module.exports = Array.isArray || function isArray(arg) {
+ return classof(arg) == 'Array';
+};
+
+/***/ }),
+/* 159 */
+/***/ (function(module, exports, __w_pdfjs_require__) {
+
+__w_pdfjs_require__(114);
+__w_pdfjs_require__(160);
+__w_pdfjs_require__(116);
+var path = __w_pdfjs_require__(43);
+module.exports = path.WeakSet;
+
+/***/ }),
+/* 160 */
+/***/ (function(module, exports, __w_pdfjs_require__) {
+
+"use strict";
+
+var collection = __w_pdfjs_require__(146);
+var collectionWeak = __w_pdfjs_require__(155);
+collection('WeakSet', function (init) {
+ return function WeakSet() {
+  return init(this, arguments.length ? arguments[0] : undefined);
+ };
+}, collectionWeak);
+
+/***/ }),
+/* 161 */
+/***/ (function(module, exports, __w_pdfjs_require__) {
+
+__w_pdfjs_require__(162);
+var entryUnbind = __w_pdfjs_require__(61);
+module.exports = entryUnbind('String', 'codePointAt');
+
+/***/ }),
+/* 162 */
+/***/ (function(module, exports, __w_pdfjs_require__) {
+
+"use strict";
+
+var $ = __w_pdfjs_require__(10);
+var codeAt = __w_pdfjs_require__(78).codeAt;
+$({
+ target: 'String',
+ proto: true
+}, {
+ codePointAt: function codePointAt(pos) {
+  return codeAt(this, pos);
+ }
+});
+
+/***/ }),
+/* 163 */
+/***/ (function(module, exports, __w_pdfjs_require__) {
+
+__w_pdfjs_require__(164);
+var path = __w_pdfjs_require__(43);
+module.exports = path.String.fromCodePoint;
+
+/***/ }),
+/* 164 */
+/***/ (function(module, exports, __w_pdfjs_require__) {
+
+var $ = __w_pdfjs_require__(10);
+var toAbsoluteIndex = __w_pdfjs_require__(49);
+var fromCharCode = String.fromCharCode;
+var nativeFromCodePoint = String.fromCodePoint;
+var INCORRECT_LENGTH = !!nativeFromCodePoint && nativeFromCodePoint.length != 1;
+$({
+ target: 'String',
+ stat: true,
+ forced: INCORRECT_LENGTH
+}, {
+ fromCodePoint: function fromCodePoint(x) {
+  var elements = [];
+  var length = arguments.length;
+  var i = 0;
+  var code;
+  while (length > i) {
+   code = +arguments[i++];
+   if (toAbsoluteIndex(code, 0x10FFFF) !== code)
+    throw RangeError(code + ' is not a valid code point');
+   elements.push(code < 0x10000 ? fromCharCode(code) : fromCharCode(((code -= 0x10000) >> 10) + 0xD800, code % 0x400 + 0xDC00));
+  }
+  return elements.join('');
+ }
+});
+
+/***/ }),
+/* 165 */
+/***/ (function(module, exports, __w_pdfjs_require__) {
+
+__w_pdfjs_require__(166);
+__w_pdfjs_require__(114);
+__w_pdfjs_require__(168);
+__w_pdfjs_require__(172);
+__w_pdfjs_require__(173);
+__w_pdfjs_require__(174);
+__w_pdfjs_require__(175);
+__w_pdfjs_require__(176);
+__w_pdfjs_require__(177);
+__w_pdfjs_require__(178);
+__w_pdfjs_require__(179);
+__w_pdfjs_require__(180);
+__w_pdfjs_require__(181);
+__w_pdfjs_require__(182);
+__w_pdfjs_require__(183);
+__w_pdfjs_require__(184);
+__w_pdfjs_require__(185);
+__w_pdfjs_require__(186);
+__w_pdfjs_require__(187);
+var path = __w_pdfjs_require__(43);
+module.exports = path.Symbol;
+
+/***/ }),
+/* 166 */
+/***/ (function(module, exports, __w_pdfjs_require__) {
+
+"use strict";
+
+var $ = __w_pdfjs_require__(10);
+var fails = __w_pdfjs_require__(14);
+var isArray = __w_pdfjs_require__(158);
+var isObject = __w_pdfjs_require__(22);
+var toObject = __w_pdfjs_require__(83);
+var toLength = __w_pdfjs_require__(47);
+var createProperty = __w_pdfjs_require__(93);
+var arraySpeciesCreate = __w_pdfjs_require__(157);
+var arrayMethodHasSpeciesSupport = __w_pdfjs_require__(167);
+var wellKnownSymbol = __w_pdfjs_require__(57);
+var V8_VERSION = __w_pdfjs_require__(133);
+var IS_CONCAT_SPREADABLE = wellKnownSymbol('isConcatSpreadable');
+var MAX_SAFE_INTEGER = 0x1FFFFFFFFFFFFF;
+var MAXIMUM_ALLOWED_INDEX_EXCEEDED = 'Maximum allowed index exceeded';
+var IS_CONCAT_SPREADABLE_SUPPORT = V8_VERSION >= 51 || !fails(function () {
+ var array = [];
+ array[IS_CONCAT_SPREADABLE] = false;
+ return array.concat()[0] !== array;
+});
+var SPECIES_SUPPORT = arrayMethodHasSpeciesSupport('concat');
+var isConcatSpreadable = function (O) {
+ if (!isObject(O))
+  return false;
+ var spreadable = O[IS_CONCAT_SPREADABLE];
+ return spreadable !== undefined ? !!spreadable : isArray(O);
+};
+var FORCED = !IS_CONCAT_SPREADABLE_SUPPORT || !SPECIES_SUPPORT;
+$({
+ target: 'Array',
+ proto: true,
+ forced: FORCED
+}, {
+ concat: function concat(arg) {
+  var O = toObject(this);
+  var A = arraySpeciesCreate(O, 0);
+  var n = 0;
+  var i, k, length, len, E;
+  for (i = -1, length = arguments.length; i < length; i++) {
+   E = i === -1 ? O : arguments[i];
+   if (isConcatSpreadable(E)) {
+    len = toLength(E.length);
+    if (n + len > MAX_SAFE_INTEGER)
+     throw TypeError(MAXIMUM_ALLOWED_INDEX_EXCEEDED);
+    for (k = 0; k < len; k++, n++)
+     if (k in E)
+      createProperty(A, n, E[k]);
+   } else {
+    if (n >= MAX_SAFE_INTEGER)
+     throw TypeError(MAXIMUM_ALLOWED_INDEX_EXCEEDED);
+    createProperty(A, n++, E);
+   }
+  }
+  A.length = n;
+  return A;
+ }
+});
+
+/***/ }),
+/* 167 */
+/***/ (function(module, exports, __w_pdfjs_require__) {
+
+var fails = __w_pdfjs_require__(14);
+var wellKnownSymbol = __w_pdfjs_require__(57);
+var V8_VERSION = __w_pdfjs_require__(133);
+var SPECIES = wellKnownSymbol('species');
+module.exports = function (METHOD_NAME) {
+ return V8_VERSION >= 51 || !fails(function () {
+  var array = [];
+  var constructor = array.constructor = {};
+  constructor[SPECIES] = function () {
+   return { foo: 1 };
+  };
+  return array[METHOD_NAME](Boolean).foo !== 1;
+ });
+};
+
+/***/ }),
+/* 168 */
+/***/ (function(module, exports, __w_pdfjs_require__) {
+
+"use strict";
+
+var $ = __w_pdfjs_require__(10);
+var global = __w_pdfjs_require__(11);
+var getBuiltIn = __w_pdfjs_require__(42);
+var IS_PURE = __w_pdfjs_require__(37);
+var DESCRIPTORS = __w_pdfjs_require__(13);
+var NATIVE_SYMBOL = __w_pdfjs_require__(58);
+var USE_SYMBOL_AS_UID = __w_pdfjs_require__(59);
+var fails = __w_pdfjs_require__(14);
+var has = __w_pdfjs_require__(23);
+var isArray = __w_pdfjs_require__(158);
+var isObject = __w_pdfjs_require__(22);
+var anObject = __w_pdfjs_require__(28);
+var toObject = __w_pdfjs_require__(83);
+var toIndexedObject = __w_pdfjs_require__(17);
+var toPrimitive = __w_pdfjs_require__(21);
+var createPropertyDescriptor = __w_pdfjs_require__(16);
+var nativeObjectCreate = __w_pdfjs_require__(71);
+var objectKeys = __w_pdfjs_require__(73);
+var getOwnPropertyNamesModule = __w_pdfjs_require__(44);
+var getOwnPropertyNamesExternal = __w_pdfjs_require__(169);
+var getOwnPropertySymbolsModule = __w_pdfjs_require__(51);
+var getOwnPropertyDescriptorModule = __w_pdfjs_require__(12);
+var definePropertyModule = __w_pdfjs_require__(27);
+var propertyIsEnumerableModule = __w_pdfjs_require__(15);
+var createNonEnumerableProperty = __w_pdfjs_require__(26);
+var redefine = __w_pdfjs_require__(29);
+var shared = __w_pdfjs_require__(36);
+var sharedKey = __w_pdfjs_require__(35);
+var hiddenKeys = __w_pdfjs_require__(39);
+var uid = __w_pdfjs_require__(38);
+var wellKnownSymbol = __w_pdfjs_require__(57);
+var wrappedWellKnownSymbolModule = __w_pdfjs_require__(170);
+var defineWellKnownSymbol = __w_pdfjs_require__(171);
+var setToStringTag = __w_pdfjs_require__(85);
+var InternalStateModule = __w_pdfjs_require__(33);
+var $forEach = __w_pdfjs_require__(156).forEach;
+var HIDDEN = sharedKey('hidden');
+var SYMBOL = 'Symbol';
+var PROTOTYPE = 'prototype';
+var TO_PRIMITIVE = wellKnownSymbol('toPrimitive');
+var setInternalState = InternalStateModule.set;
+var getInternalState = InternalStateModule.getterFor(SYMBOL);
+var ObjectPrototype = Object[PROTOTYPE];
+var $Symbol = global.Symbol;
+var $stringify = getBuiltIn('JSON', 'stringify');
+var nativeGetOwnPropertyDescriptor = getOwnPropertyDescriptorModule.f;
+var nativeDefineProperty = definePropertyModule.f;
+var nativeGetOwnPropertyNames = getOwnPropertyNamesExternal.f;
+var nativePropertyIsEnumerable = propertyIsEnumerableModule.f;
+var AllSymbols = shared('symbols');
+var ObjectPrototypeSymbols = shared('op-symbols');
+var StringToSymbolRegistry = shared('string-to-symbol-registry');
+var SymbolToStringRegistry = shared('symbol-to-string-registry');
+var WellKnownSymbolsStore = shared('wks');
+var QObject = global.QObject;
+var USE_SETTER = !QObject || !QObject[PROTOTYPE] || !QObject[PROTOTYPE].findChild;
+var setSymbolDescriptor = DESCRIPTORS && fails(function () {
+ return nativeObjectCreate(nativeDefineProperty({}, 'a', {
+  get: function () {
+   return nativeDefineProperty(this, 'a', { value: 7 }).a;
+  }
+ })).a != 7;
+}) ? function (O, P, Attributes) {
+ var ObjectPrototypeDescriptor = nativeGetOwnPropertyDescriptor(ObjectPrototype, P);
+ if (ObjectPrototypeDescriptor)
+  delete ObjectPrototype[P];
+ nativeDefineProperty(O, P, Attributes);
+ if (ObjectPrototypeDescriptor && O !== ObjectPrototype) {
+  nativeDefineProperty(ObjectPrototype, P, ObjectPrototypeDescriptor);
+ }
+} : nativeDefineProperty;
+var wrap = function (tag, description) {
+ var symbol = AllSymbols[tag] = nativeObjectCreate($Symbol[PROTOTYPE]);
+ setInternalState(symbol, {
+  type: SYMBOL,
+  tag: tag,
+  description: description
+ });
+ if (!DESCRIPTORS)
+  symbol.description = description;
+ return symbol;
+};
+var isSymbol = USE_SYMBOL_AS_UID ? function (it) {
+ return typeof it == 'symbol';
+} : function (it) {
+ return Object(it) instanceof $Symbol;
+};
+var $defineProperty = function defineProperty(O, P, Attributes) {
+ if (O === ObjectPrototype)
+  $defineProperty(ObjectPrototypeSymbols, P, Attributes);
+ anObject(O);
+ var key = toPrimitive(P, true);
+ anObject(Attributes);
+ if (has(AllSymbols, key)) {
+  if (!Attributes.enumerable) {
+   if (!has(O, HIDDEN))
+    nativeDefineProperty(O, HIDDEN, createPropertyDescriptor(1, {}));
+   O[HIDDEN][key] = true;
+  } else {
+   if (has(O, HIDDEN) && O[HIDDEN][key])
+    O[HIDDEN][key] = false;
+   Attributes = nativeObjectCreate(Attributes, { enumerable: createPropertyDescriptor(0, false) });
+  }
+  return setSymbolDescriptor(O, key, Attributes);
+ }
+ return nativeDefineProperty(O, key, Attributes);
+};
+var $defineProperties = function defineProperties(O, Properties) {
+ anObject(O);
+ var properties = toIndexedObject(Properties);
+ var keys = objectKeys(properties).concat($getOwnPropertySymbols(properties));
+ $forEach(keys, function (key) {
+  if (!DESCRIPTORS || $propertyIsEnumerable.call(properties, key))
+   $defineProperty(O, key, properties[key]);
+ });
+ return O;
+};
+var $create = function create(O, Properties) {
+ return Properties === undefined ? nativeObjectCreate(O) : $defineProperties(nativeObjectCreate(O), Properties);
+};
+var $propertyIsEnumerable = function propertyIsEnumerable(V) {
+ var P = toPrimitive(V, true);
+ var enumerable = nativePropertyIsEnumerable.call(this, P);
+ if (this === ObjectPrototype && has(AllSymbols, P) && !has(ObjectPrototypeSymbols, P))
+  return false;
+ return enumerable || !has(this, P) || !has(AllSymbols, P) || has(this, HIDDEN) && this[HIDDEN][P] ? enumerable : true;
+};
+var $getOwnPropertyDescriptor = function getOwnPropertyDescriptor(O, P) {
+ var it = toIndexedObject(O);
+ var key = toPrimitive(P, true);
+ if (it === ObjectPrototype && has(AllSymbols, key) && !has(ObjectPrototypeSymbols, key))
+  return;
+ var descriptor = nativeGetOwnPropertyDescriptor(it, key);
+ if (descriptor && has(AllSymbols, key) && !(has(it, HIDDEN) && it[HIDDEN][key])) {
+  descriptor.enumerable = true;
+ }
+ return descriptor;
+};
+var $getOwnPropertyNames = function getOwnPropertyNames(O) {
+ var names = nativeGetOwnPropertyNames(toIndexedObject(O));
+ var result = [];
+ $forEach(names, function (key) {
+  if (!has(AllSymbols, key) && !has(hiddenKeys, key))
+   result.push(key);
+ });
+ return result;
+};
+var $getOwnPropertySymbols = function getOwnPropertySymbols(O) {
+ var IS_OBJECT_PROTOTYPE = O === ObjectPrototype;
+ var names = nativeGetOwnPropertyNames(IS_OBJECT_PROTOTYPE ? ObjectPrototypeSymbols : toIndexedObject(O));
+ var result = [];
+ $forEach(names, function (key) {
+  if (has(AllSymbols, key) && (!IS_OBJECT_PROTOTYPE || has(ObjectPrototype, key))) {
+   result.push(AllSymbols[key]);
+  }
+ });
+ return result;
+};
+if (!NATIVE_SYMBOL) {
+ $Symbol = function Symbol() {
+  if (this instanceof $Symbol)
+   throw TypeError('Symbol is not a constructor');
+  var description = !arguments.length || arguments[0] === undefined ? undefined : String(arguments[0]);
+  var tag = uid(description);
+  var setter = function (value) {
+   if (this === ObjectPrototype)
+    setter.call(ObjectPrototypeSymbols, value);
+   if (has(this, HIDDEN) && has(this[HIDDEN], tag))
+    this[HIDDEN][tag] = false;
+   setSymbolDescriptor(this, tag, createPropertyDescriptor(1, value));
+  };
+  if (DESCRIPTORS && USE_SETTER)
+   setSymbolDescriptor(ObjectPrototype, tag, {
+    configurable: true,
+    set: setter
+   });
+  return wrap(tag, description);
+ };
+ redefine($Symbol[PROTOTYPE], 'toString', function toString() {
+  return getInternalState(this).tag;
+ });
+ redefine($Symbol, 'withoutSetter', function (description) {
+  return wrap(uid(description), description);
+ });
+ propertyIsEnumerableModule.f = $propertyIsEnumerable;
+ definePropertyModule.f = $defineProperty;
+ getOwnPropertyDescriptorModule.f = $getOwnPropertyDescriptor;
+ getOwnPropertyNamesModule.f = getOwnPropertyNamesExternal.f = $getOwnPropertyNames;
+ getOwnPropertySymbolsModule.f = $getOwnPropertySymbols;
+ wrappedWellKnownSymbolModule.f = function (name) {
+  return wrap(wellKnownSymbol(name), name);
+ };
+ if (DESCRIPTORS) {
+  nativeDefineProperty($Symbol[PROTOTYPE], 'description', {
+   configurable: true,
+   get: function description() {
+    return getInternalState(this).description;
+   }
+  });
+  if (!IS_PURE) {
+   redefine(ObjectPrototype, 'propertyIsEnumerable', $propertyIsEnumerable, { unsafe: true });
+  }
+ }
+}
+$({
+ global: true,
+ wrap: true,
+ forced: !NATIVE_SYMBOL,
+ sham: !NATIVE_SYMBOL
+}, { Symbol: $Symbol });
+$forEach(objectKeys(WellKnownSymbolsStore), function (name) {
+ defineWellKnownSymbol(name);
+});
+$({
+ target: SYMBOL,
+ stat: true,
+ forced: !NATIVE_SYMBOL
+}, {
+ 'for': function (key) {
+  var string = String(key);
+  if (has(StringToSymbolRegistry, string))
+   return StringToSymbolRegistry[string];
+  var symbol = $Symbol(string);
+  StringToSymbolRegistry[string] = symbol;
+  SymbolToStringRegistry[symbol] = string;
+  return symbol;
+ },
+ keyFor: function keyFor(sym) {
+  if (!isSymbol(sym))
+   throw TypeError(sym + ' is not a symbol');
+  if (has(SymbolToStringRegistry, sym))
+   return SymbolToStringRegistry[sym];
+ },
+ useSetter: function () {
+  USE_SETTER = true;
+ },
+ useSimple: function () {
+  USE_SETTER = false;
+ }
+});
+$({
+ target: 'Object',
+ stat: true,
+ forced: !NATIVE_SYMBOL,
+ sham: !DESCRIPTORS
+}, {
+ create: $create,
+ defineProperty: $defineProperty,
+ defineProperties: $defineProperties,
+ getOwnPropertyDescriptor: $getOwnPropertyDescriptor
+});
+$({
+ target: 'Object',
+ stat: true,
+ forced: !NATIVE_SYMBOL
+}, {
+ getOwnPropertyNames: $getOwnPropertyNames,
+ getOwnPropertySymbols: $getOwnPropertySymbols
+});
+$({
+ target: 'Object',
+ stat: true,
+ forced: fails(function () {
+  getOwnPropertySymbolsModule.f(1);
+ })
+}, {
+ getOwnPropertySymbols: function getOwnPropertySymbols(it) {
+  return getOwnPropertySymbolsModule.f(toObject(it));
+ }
+});
+if ($stringify) {
+ var FORCED_JSON_STRINGIFY = !NATIVE_SYMBOL || fails(function () {
+  var symbol = $Symbol();
+  return $stringify([symbol]) != '[null]' || $stringify({ a: symbol }) != '{}' || $stringify(Object(symbol)) != '{}';
+ });
+ $({
+  target: 'JSON',
+  stat: true,
+  forced: FORCED_JSON_STRINGIFY
+ }, {
+  stringify: function stringify(it, replacer, space) {
+   var args = [it];
+   var index = 1;
+   var $replacer;
+   while (arguments.length > index)
+    args.push(arguments[index++]);
+   $replacer = replacer;
+   if (!isObject(replacer) && it === undefined || isSymbol(it))
+    return;
+   if (!isArray(replacer))
+    replacer = function (key, value) {
+     if (typeof $replacer == 'function')
+      value = $replacer.call(this, key, value);
+     if (!isSymbol(value))
+      return value;
+    };
+   args[1] = replacer;
+   return $stringify.apply(null, args);
+  }
+ });
+}
+if (!$Symbol[PROTOTYPE][TO_PRIMITIVE]) {
+ createNonEnumerableProperty($Symbol[PROTOTYPE], TO_PRIMITIVE, $Symbol[PROTOTYPE].valueOf);
+}
+setToStringTag($Symbol, SYMBOL);
+hiddenKeys[HIDDEN] = true;
+
+/***/ }),
+/* 169 */
+/***/ (function(module, exports, __w_pdfjs_require__) {
+
+var toIndexedObject = __w_pdfjs_require__(17);
+var nativeGetOwnPropertyNames = __w_pdfjs_require__(44).f;
+var toString = {}.toString;
+var windowNames = typeof window == 'object' && window && Object.getOwnPropertyNames ? Object.getOwnPropertyNames(window) : [];
+var getWindowNames = function (it) {
+ try {
+  return nativeGetOwnPropertyNames(it);
+ } catch (error) {
+  return windowNames.slice();
+ }
+};
+module.exports.f = function getOwnPropertyNames(it) {
+ return windowNames && toString.call(it) == '[object Window]' ? getWindowNames(it) : nativeGetOwnPropertyNames(toIndexedObject(it));
+};
+
+/***/ }),
+/* 170 */
+/***/ (function(module, exports, __w_pdfjs_require__) {
+
+var wellKnownSymbol = __w_pdfjs_require__(57);
+exports.f = wellKnownSymbol;
+
+/***/ }),
+/* 171 */
+/***/ (function(module, exports, __w_pdfjs_require__) {
+
+var path = __w_pdfjs_require__(43);
+var has = __w_pdfjs_require__(23);
+var wrappedWellKnownSymbolModule = __w_pdfjs_require__(170);
+var defineProperty = __w_pdfjs_require__(27).f;
+module.exports = function (NAME) {
+ var Symbol = path.Symbol || (path.Symbol = {});
+ if (!has(Symbol, NAME))
+  defineProperty(Symbol, NAME, { value: wrappedWellKnownSymbolModule.f(NAME) });
+};
+
+/***/ }),
+/* 172 */
+/***/ (function(module, exports, __w_pdfjs_require__) {
+
+var defineWellKnownSymbol = __w_pdfjs_require__(171);
+defineWellKnownSymbol('asyncIterator');
+
+/***/ }),
+/* 173 */
+/***/ (function(module, exports, __w_pdfjs_require__) {
+
+"use strict";
+
+var $ = __w_pdfjs_require__(10);
+var DESCRIPTORS = __w_pdfjs_require__(13);
+var global = __w_pdfjs_require__(11);
+var has = __w_pdfjs_require__(23);
+var isObject = __w_pdfjs_require__(22);
+var defineProperty = __w_pdfjs_require__(27).f;
+var copyConstructorProperties = __w_pdfjs_require__(40);
+var NativeSymbol = global.Symbol;
+if (DESCRIPTORS && typeof NativeSymbol == 'function' && (!('description' in NativeSymbol.prototype) || NativeSymbol().description !== undefined)) {
+ var EmptyStringDescriptionStore = {};
+ var SymbolWrapper = function Symbol() {
+  var description = arguments.length < 1 || arguments[0] === undefined ? undefined : String(arguments[0]);
+  var result = this instanceof SymbolWrapper ? new NativeSymbol(description) : description === undefined ? NativeSymbol() : NativeSymbol(description);
+  if (description === '')
+   EmptyStringDescriptionStore[result] = true;
+  return result;
+ };
+ copyConstructorProperties(SymbolWrapper, NativeSymbol);
+ var symbolPrototype = SymbolWrapper.prototype = NativeSymbol.prototype;
+ symbolPrototype.constructor = SymbolWrapper;
+ var symbolToString = symbolPrototype.toString;
+ var native = String(NativeSymbol('test')) == 'Symbol(test)';
+ var regexp = /^Symbol\((.*)\)[^)]+$/;
+ defineProperty(symbolPrototype, 'description', {
+  configurable: true,
+  get: function description() {
+   var symbol = isObject(this) ? this.valueOf() : this;
+   var string = symbolToString.call(symbol);
+   if (has(EmptyStringDescriptionStore, symbol))
+    return '';
+   var desc = native ? string.slice(7, -1) : string.replace(regexp, '$1');
+   return desc === '' ? undefined : desc;
+  }
+ });
+ $({
+  global: true,
+  forced: true
+ }, { Symbol: SymbolWrapper });
+}
+
+/***/ }),
+/* 174 */
+/***/ (function(module, exports, __w_pdfjs_require__) {
+
+var defineWellKnownSymbol = __w_pdfjs_require__(171);
+defineWellKnownSymbol('hasInstance');
+
+/***/ }),
+/* 175 */
+/***/ (function(module, exports, __w_pdfjs_require__) {
+
+var defineWellKnownSymbol = __w_pdfjs_require__(171);
+defineWellKnownSymbol('isConcatSpreadable');
+
+/***/ }),
+/* 176 */
+/***/ (function(module, exports, __w_pdfjs_require__) {
+
+var defineWellKnownSymbol = __w_pdfjs_require__(171);
+defineWellKnownSymbol('iterator');
+
+/***/ }),
+/* 177 */
+/***/ (function(module, exports, __w_pdfjs_require__) {
+
+var defineWellKnownSymbol = __w_pdfjs_require__(171);
+defineWellKnownSymbol('match');
+
+/***/ }),
+/* 178 */
+/***/ (function(module, exports, __w_pdfjs_require__) {
+
+var defineWellKnownSymbol = __w_pdfjs_require__(171);
+defineWellKnownSymbol('matchAll');
+
+/***/ }),
+/* 179 */
+/***/ (function(module, exports, __w_pdfjs_require__) {
+
+var defineWellKnownSymbol = __w_pdfjs_require__(171);
+defineWellKnownSymbol('replace');
+
+/***/ }),
+/* 180 */
+/***/ (function(module, exports, __w_pdfjs_require__) {
+
+var defineWellKnownSymbol = __w_pdfjs_require__(171);
+defineWellKnownSymbol('search');
+
+/***/ }),
+/* 181 */
+/***/ (function(module, exports, __w_pdfjs_require__) {
+
+var defineWellKnownSymbol = __w_pdfjs_require__(171);
+defineWellKnownSymbol('species');
+
+/***/ }),
+/* 182 */
+/***/ (function(module, exports, __w_pdfjs_require__) {
+
+var defineWellKnownSymbol = __w_pdfjs_require__(171);
+defineWellKnownSymbol('split');
+
+/***/ }),
+/* 183 */
+/***/ (function(module, exports, __w_pdfjs_require__) {
+
+var defineWellKnownSymbol = __w_pdfjs_require__(171);
+defineWellKnownSymbol('toPrimitive');
+
+/***/ }),
+/* 184 */
+/***/ (function(module, exports, __w_pdfjs_require__) {
+
+var defineWellKnownSymbol = __w_pdfjs_require__(171);
+defineWellKnownSymbol('toStringTag');
+
+/***/ }),
+/* 185 */
+/***/ (function(module, exports, __w_pdfjs_require__) {
+
+var defineWellKnownSymbol = __w_pdfjs_require__(171);
+defineWellKnownSymbol('unscopables');
+
+/***/ }),
+/* 186 */
+/***/ (function(module, exports, __w_pdfjs_require__) {
+
+var setToStringTag = __w_pdfjs_require__(85);
+setToStringTag(Math, 'Math', true);
+
+/***/ }),
+/* 187 */
+/***/ (function(module, exports, __w_pdfjs_require__) {
+
+var global = __w_pdfjs_require__(11);
+var setToStringTag = __w_pdfjs_require__(85);
+setToStringTag(global.JSON, 'JSON', true);
+
+/***/ }),
+/* 188 */
+/***/ (function(module, exports, __w_pdfjs_require__) {
+
+__w_pdfjs_require__(189);
+var entryUnbind = __w_pdfjs_require__(61);
+module.exports = entryUnbind('String', 'padStart');
+
+/***/ }),
+/* 189 */
+/***/ (function(module, exports, __w_pdfjs_require__) {
+
+"use strict";
+
+var $ = __w_pdfjs_require__(10);
+var $padStart = __w_pdfjs_require__(190).start;
+var WEBKIT_BUG = __w_pdfjs_require__(192);
+$({
+ target: 'String',
+ proto: true,
+ forced: WEBKIT_BUG
+}, {
+ padStart: function padStart(maxLength) {
+  return $padStart(this, maxLength, arguments.length > 1 ? arguments[1] : undefined);
+ }
+});
+
+/***/ }),
+/* 190 */
+/***/ (function(module, exports, __w_pdfjs_require__) {
+
+var toLength = __w_pdfjs_require__(47);
+var repeat = __w_pdfjs_require__(191);
+var requireObjectCoercible = __w_pdfjs_require__(20);
+var ceil = Math.ceil;
+var createMethod = function (IS_END) {
+ return function ($this, maxLength, fillString) {
+  var S = String(requireObjectCoercible($this));
+  var stringLength = S.length;
+  var fillStr = fillString === undefined ? ' ' : String(fillString);
+  var intMaxLength = toLength(maxLength);
+  var fillLen, stringFiller;
+  if (intMaxLength <= stringLength || fillStr == '')
+   return S;
+  fillLen = intMaxLength - stringLength;
+  stringFiller = repeat.call(fillStr, ceil(fillLen / fillStr.length));
+  if (stringFiller.length > fillLen)
+   stringFiller = stringFiller.slice(0, fillLen);
+  return IS_END ? S + stringFiller : stringFiller + S;
+ };
+};
+module.exports = {
+ start: createMethod(false),
+ end: createMethod(true)
+};
+
+/***/ }),
+/* 191 */
+/***/ (function(module, exports, __w_pdfjs_require__) {
+
+"use strict";
+
+var toInteger = __w_pdfjs_require__(48);
+var requireObjectCoercible = __w_pdfjs_require__(20);
+module.exports = ''.repeat || function repeat(count) {
+ var str = String(requireObjectCoercible(this));
+ var result = '';
+ var n = toInteger(count);
+ if (n < 0 || n == Infinity)
+  throw RangeError('Wrong number of repetitions');
+ for (; n > 0; (n >>>= 1) && (str += str))
+  if (n & 1)
+   result += str;
+ return result;
+};
+
+/***/ }),
+/* 192 */
+/***/ (function(module, exports, __w_pdfjs_require__) {
+
+var userAgent = __w_pdfjs_require__(127);
+module.exports = /Version\/10\.\d+(\.\d+)?( Mobile\/\w+)? Safari\//.test(userAgent);
+
+/***/ }),
+/* 193 */
+/***/ (function(module, exports, __w_pdfjs_require__) {
+
+__w_pdfjs_require__(194);
+var entryUnbind = __w_pdfjs_require__(61);
+module.exports = entryUnbind('String', 'padEnd');
+
+/***/ }),
+/* 194 */
+/***/ (function(module, exports, __w_pdfjs_require__) {
+
+"use strict";
+
+var $ = __w_pdfjs_require__(10);
+var $padEnd = __w_pdfjs_require__(190).end;
+var WEBKIT_BUG = __w_pdfjs_require__(192);
+$({
+ target: 'String',
+ proto: true,
+ forced: WEBKIT_BUG
+}, {
+ padEnd: function padEnd(maxLength) {
+  return $padEnd(this, maxLength, arguments.length > 1 ? arguments[1] : undefined);
+ }
+});
+
+/***/ }),
+/* 195 */
+/***/ (function(module, exports, __w_pdfjs_require__) {
+
+__w_pdfjs_require__(196);
+var path = __w_pdfjs_require__(43);
+module.exports = path.Object.values;
+
+/***/ }),
+/* 196 */
+/***/ (function(module, exports, __w_pdfjs_require__) {
+
+var $ = __w_pdfjs_require__(10);
+var $values = __w_pdfjs_require__(197).values;
+$({
+ target: 'Object',
+ stat: true
+}, {
+ values: function values(O) {
+  return $values(O);
+ }
+});
+
+/***/ }),
+/* 197 */
+/***/ (function(module, exports, __w_pdfjs_require__) {
+
+var DESCRIPTORS = __w_pdfjs_require__(13);
+var objectKeys = __w_pdfjs_require__(73);
+var toIndexedObject = __w_pdfjs_require__(17);
+var propertyIsEnumerable = __w_pdfjs_require__(15).f;
+var createMethod = function (TO_ENTRIES) {
+ return function (it) {
+  var O = toIndexedObject(it);
+  var keys = objectKeys(O);
+  var length = keys.length;
+  var i = 0;
+  var result = [];
+  var key;
+  while (length > i) {
+   key = keys[i++];
+   if (!DESCRIPTORS || propertyIsEnumerable.call(O, key)) {
+    result.push(TO_ENTRIES ? [
+     key,
+     O[key]
+    ] : O[key]);
+   }
+  }
+  return result;
+ };
+};
+module.exports = {
+ entries: createMethod(true),
+ values: createMethod(false)
+};
+
+/***/ }),
+/* 198 */
 /***/ (function(module, exports, __w_pdfjs_require__) {
 
 "use strict";
@@ -1734,39 +12073,77 @@ exports.getDocument = getDocument;
 exports.setPDFNetworkStreamFactory = setPDFNetworkStreamFactory;
 exports.build = exports.version = exports.PDFPageProxy = exports.PDFDocumentProxy = exports.PDFWorker = exports.PDFDataRangeTransport = exports.LoopbackPort = void 0;
 
-var _util = __w_pdfjs_require__(2);
+var _regenerator = _interopRequireDefault(__w_pdfjs_require__(2));
+
+var _util = __w_pdfjs_require__(5);
 
 var _display_utils = __w_pdfjs_require__(1);
 
-var _font_loader = __w_pdfjs_require__(6);
+var _font_loader = __w_pdfjs_require__(199);
+
+var _api_compatibility = __w_pdfjs_require__(200);
 
-var _api_compatibility = __w_pdfjs_require__(7);
+var _canvas = __w_pdfjs_require__(201);
 
-var _canvas = __w_pdfjs_require__(8);
+var _worker_options = __w_pdfjs_require__(203);
 
-var _worker_options = __w_pdfjs_require__(10);
+var _is_node = __w_pdfjs_require__(7);
 
-var _is_node = __w_pdfjs_require__(4);
+var _message_handler = __w_pdfjs_require__(204);
 
-var _message_handler = __w_pdfjs_require__(11);
+var _metadata = __w_pdfjs_require__(205);
 
-var _metadata = __w_pdfjs_require__(12);
+var _transport_stream = __w_pdfjs_require__(207);
 
-var _transport_stream = __w_pdfjs_require__(14);
+var _webgl = __w_pdfjs_require__(208);
 
-var _webgl = __w_pdfjs_require__(15);
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
 
-const DEFAULT_RANGE_CHUNK_SIZE = 65536;
-const RENDERING_CANCELLED_TIMEOUT = 100;
-let createPDFNetworkStream;
+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 _toConsumableArray(arr) { return _arrayWithoutHoles(arr) || _iterableToArray(arr) || _unsupportedIterableToArray(arr) || _nonIterableSpread(); }
+
+function _nonIterableSpread() { throw new TypeError("Invalid attempt to spread non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method."); }
+
+function _iterableToArray(iter) { if (typeof Symbol !== "undefined" && Symbol.iterator in Object(iter)) return Array.from(iter); }
+
+function _arrayWithoutHoles(arr) { if (Array.isArray(arr)) return _arrayLikeToArray(arr); }
+
+function _createForOfIteratorHelper(o, allowArrayLike) { var it; if (typeof Symbol === "undefined" || o[Symbol.iterator] == null) { if (Array.isArray(o) || (it = _unsupportedIterableToArray(o)) || allowArrayLike && o && typeof o.length === "number") { if (it) o = it; var i = 0; var F = function F() {}; return { s: F, n: function n() { if (i >= o.length) return { done: true }; return { done: false, value: o[i++] }; }, e: function e(_e2) { throw _e2; }, f: F }; } throw new TypeError("Invalid attempt to iterate non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method."); } var normalCompletion = true, didErr = false, err; return { s: function s() { it = o[Symbol.iterator](); }, n: function n() { var step = it.next(); normalCompletion = step.done; return step; }, e: function e(_e3) { didErr = true; err = _e3; }, f: function f() { try { if (!normalCompletion && it["return"] != null) it["return"](); } finally { if (didErr) throw err; } } }; }
+
+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; }
+
+function _slicedToArray(arr, i) { return _arrayWithHoles(arr) || _iterableToArrayLimit(arr, i) || _unsupportedIterableToArray(arr, i) || _nonIterableRest(); }
+
+function _nonIterableRest() { throw new TypeError("Invalid attempt to destructure non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method."); }
+
+function _unsupportedIterableToArray(o, minLen) { if (!o) return; if (typeof o === "string") return _arrayLikeToArray(o, minLen); var n = Object.prototype.toString.call(o).slice(8, -1); if (n === "Object" && o.constructor) n = o.constructor.name; if (n === "Map" || n === "Set") return Array.from(o); if (n === "Arguments" || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(n)) return _arrayLikeToArray(o, minLen); }
+
+function _arrayLikeToArray(arr, len) { if (len == null || len > arr.length) len = arr.length; for (var i = 0, arr2 = new Array(len); i < len; i++) { arr2[i] = arr[i]; } return arr2; }
+
+function _iterableToArrayLimit(arr, i) { if (typeof Symbol === "undefined" || !(Symbol.iterator in Object(arr))) return; var _arr = []; var _n = true; var _d = false; var _e = undefined; try { for (var _i = arr[Symbol.iterator](), _s; !(_n = (_s = _i.next()).done); _n = true) { _arr.push(_s.value); if (i && _arr.length === i) break; } } catch (err) { _d = true; _e = err; } finally { try { if (!_n && _i["return"] != null) _i["return"](); } finally { if (_d) throw _e; } } return _arr; }
+
+function _arrayWithHoles(arr) { if (Array.isArray(arr)) return arr; }
+
+function _typeof(obj) { "@babel/helpers - typeof"; 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); }
+
+var DEFAULT_RANGE_CHUNK_SIZE = 65536;
+var RENDERING_CANCELLED_TIMEOUT = 100;
+var createPDFNetworkStream;
 
 function setPDFNetworkStreamFactory(pdfNetworkStreamFactory) {
   createPDFNetworkStream = pdfNetworkStreamFactory;
 }
 
 function getDocument(src) {
-  const task = new PDFDocumentLoadingTask();
-  let source;
+  var task = new PDFDocumentLoadingTask();
+  var source;
 
   if (typeof src === "string") {
     source = {
@@ -1781,7 +12158,7 @@ function getDocument(src) {
       range: src
     };
   } else {
-    if (typeof src !== "object") {
+    if (_typeof(src) !== "object") {
       throw new Error("Invalid parameter in getDocument, " + "need either Uint8Array, string or a parameter object");
     }
 
@@ -1792,11 +12169,11 @@ function getDocument(src) {
     source = src;
   }
 
-  const params = Object.create(null);
-  let rangeTransport = null,
+  var params = Object.create(null);
+  var rangeTransport = null,
       worker = null;
 
-  for (const key in source) {
+  for (var key in source) {
     if (key === "url" && typeof window !== "undefined") {
       params[key] = new URL(source[key], window.location).href;
       continue;
@@ -1807,11 +12184,11 @@ function getDocument(src) {
       worker = source[key];
       continue;
     } else if (key === "data" && !(source[key] instanceof Uint8Array)) {
-      const pdfBytes = source[key];
+      var pdfBytes = source[key];
 
       if (typeof pdfBytes === "string") {
         params[key] = (0, _util.stringToBytes)(pdfBytes);
-      } else if (typeof pdfBytes === "object" && pdfBytes !== null && !isNaN(pdfBytes.length)) {
+      } else if (_typeof(pdfBytes) === "object" && pdfBytes !== null && !isNaN(pdfBytes.length)) {
         params[key] = new Uint8Array(pdfBytes);
       } else if ((0, _util.isArrayBuffer)(pdfBytes)) {
         params[key] = new Uint8Array(pdfBytes);
@@ -1858,7 +12235,7 @@ function getDocument(src) {
   (0, _util.setVerbosityLevel)(params.verbosity);
 
   if (!worker) {
-    const workerParams = {
+    var workerParams = {
       verbosity: params.verbosity,
       port: _worker_options.GlobalWorkerOptions.workerPort
     };
@@ -1866,16 +12243,16 @@ function getDocument(src) {
     task._worker = worker;
   }
 
-  const docId = task.docId;
+  var docId = task.docId;
   worker.promise.then(function () {
     if (task.destroyed) {
       throw new Error("Loading aborted");
     }
 
-    const workerIdPromise = _fetchDocument(worker, params, rangeTransport, docId);
+    var workerIdPromise = _fetchDocument(worker, params, rangeTransport, docId);
 
-    const networkStreamPromise = new Promise(function (resolve) {
-      let networkStream;
+    var networkStreamPromise = new Promise(function (resolve) {
+      var networkStream;
 
       if (rangeTransport) {
         networkStream = new _transport_stream.PDFDataTransportStream({
@@ -1899,18 +12276,22 @@ function getDocument(src) {
 
       resolve(networkStream);
     });
-    return Promise.all([workerIdPromise, networkStreamPromise]).then(function ([workerId, networkStream]) {
+    return Promise.all([workerIdPromise, networkStreamPromise]).then(function (_ref) {
+      var _ref2 = _slicedToArray(_ref, 2),
+          workerId = _ref2[0],
+          networkStream = _ref2[1];
+
       if (task.destroyed) {
         throw new Error("Loading aborted");
       }
 
-      const messageHandler = new _message_handler.MessageHandler(docId, workerId, worker.port);
+      var messageHandler = new _message_handler.MessageHandler(docId, workerId, worker.port);
       messageHandler.postMessageTransfers = worker.postMessageTransfers;
-      const transport = new WorkerTransport(messageHandler, task, networkStream, params);
+      var transport = new WorkerTransport(messageHandler, task, networkStream, params);
       task._transport = transport;
       messageHandler.send("Ready", null);
     });
-  }).catch(task._capability.reject);
+  })["catch"](task._capability.reject);
   return task;
 }
 
@@ -1926,7 +12307,7 @@ function _fetchDocument(worker, source, pdfDataRangeTransport, docId) {
   }
 
   return worker.messageHandler.sendWithPromise("GetDocRequest", {
-    docId,
+    docId: docId,
     apiVersion: '2.5.207',
     source: {
       data: source.data,
@@ -1952,11 +12333,13 @@ function _fetchDocument(worker, source, pdfDataRangeTransport, docId) {
   });
 }
 
-const PDFDocumentLoadingTask = function PDFDocumentLoadingTaskClosure() {
-  let nextDocumentId = 0;
+var PDFDocumentLoadingTask = function PDFDocumentLoadingTaskClosure() {
+  var nextDocumentId = 0;
+
+  var PDFDocumentLoadingTask = /*#__PURE__*/function () {
+    function PDFDocumentLoadingTask() {
+      _classCallCheck(this, PDFDocumentLoadingTask);
 
-  class PDFDocumentLoadingTask {
-    constructor() {
       this._capability = (0, _util.createPromiseCapability)();
       this._transport = null;
       this._worker = null;
@@ -1967,31 +12350,42 @@ const PDFDocumentLoadingTask = function PDFDocumentLoadingTaskClosure() {
       this.onUnsupportedFeature = null;
     }
 
-    get promise() {
-      return this._capability.promise;
-    }
+    _createClass(PDFDocumentLoadingTask, [{
+      key: "destroy",
+      value: function destroy() {
+        var _this = this;
 
-    destroy() {
-      this.destroyed = true;
-      const transportDestroyed = !this._transport ? Promise.resolve() : this._transport.destroy();
-      return transportDestroyed.then(() => {
-        this._transport = null;
+        this.destroyed = true;
+        var transportDestroyed = !this._transport ? Promise.resolve() : this._transport.destroy();
+        return transportDestroyed.then(function () {
+          _this._transport = null;
 
-        if (this._worker) {
-          this._worker.destroy();
+          if (_this._worker) {
+            _this._worker.destroy();
 
-          this._worker = null;
-        }
-      });
-    }
+            _this._worker = null;
+          }
+        });
+      }
+    }, {
+      key: "promise",
+      get: function get() {
+        return this._capability.promise;
+      }
+    }]);
 
-  }
+    return PDFDocumentLoadingTask;
+  }();
 
   return PDFDocumentLoadingTask;
 }();
 
-class PDFDataRangeTransport {
-  constructor(length, initialData, progressiveDone = false) {
+var PDFDataRangeTransport = /*#__PURE__*/function () {
+  function PDFDataRangeTransport(length, initialData) {
+    var progressiveDone = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : false;
+
+    _classCallCheck(this, PDFDataRangeTransport);
+
     this.length = length;
     this.initialData = initialData;
     this.progressiveDone = progressiveDone;
@@ -2002,177 +12396,270 @@ class PDFDataRangeTransport {
     this._readyCapability = (0, _util.createPromiseCapability)();
   }
 
-  addRangeListener(listener) {
-    this._rangeListeners.push(listener);
-  }
-
-  addProgressListener(listener) {
-    this._progressListeners.push(listener);
-  }
-
-  addProgressiveReadListener(listener) {
-    this._progressiveReadListeners.push(listener);
-  }
-
-  addProgressiveDoneListener(listener) {
-    this._progressiveDoneListeners.push(listener);
-  }
-
-  onDataRange(begin, chunk) {
-    for (const listener of this._rangeListeners) {
-      listener(begin, chunk);
+  _createClass(PDFDataRangeTransport, [{
+    key: "addRangeListener",
+    value: function addRangeListener(listener) {
+      this._rangeListeners.push(listener);
     }
-  }
+  }, {
+    key: "addProgressListener",
+    value: function addProgressListener(listener) {
+      this._progressListeners.push(listener);
+    }
+  }, {
+    key: "addProgressiveReadListener",
+    value: function addProgressiveReadListener(listener) {
+      this._progressiveReadListeners.push(listener);
+    }
+  }, {
+    key: "addProgressiveDoneListener",
+    value: function addProgressiveDoneListener(listener) {
+      this._progressiveDoneListeners.push(listener);
+    }
+  }, {
+    key: "onDataRange",
+    value: function onDataRange(begin, chunk) {
+      var _iterator = _createForOfIteratorHelper(this._rangeListeners),
+          _step;
 
-  onDataProgress(loaded, total) {
-    this._readyCapability.promise.then(() => {
-      for (const listener of this._progressListeners) {
-        listener(loaded, total);
+      try {
+        for (_iterator.s(); !(_step = _iterator.n()).done;) {
+          var listener = _step.value;
+          listener(begin, chunk);
+        }
+      } catch (err) {
+        _iterator.e(err);
+      } finally {
+        _iterator.f();
       }
-    });
-  }
+    }
+  }, {
+    key: "onDataProgress",
+    value: function onDataProgress(loaded, total) {
+      var _this2 = this;
 
-  onDataProgressiveRead(chunk) {
-    this._readyCapability.promise.then(() => {
-      for (const listener of this._progressiveReadListeners) {
-        listener(chunk);
-      }
-    });
-  }
+      this._readyCapability.promise.then(function () {
+        var _iterator2 = _createForOfIteratorHelper(_this2._progressListeners),
+            _step2;
 
-  onDataProgressiveDone() {
-    this._readyCapability.promise.then(() => {
-      for (const listener of this._progressiveDoneListeners) {
-        listener();
-      }
-    });
-  }
+        try {
+          for (_iterator2.s(); !(_step2 = _iterator2.n()).done;) {
+            var listener = _step2.value;
+            listener(loaded, total);
+          }
+        } catch (err) {
+          _iterator2.e(err);
+        } finally {
+          _iterator2.f();
+        }
+      });
+    }
+  }, {
+    key: "onDataProgressiveRead",
+    value: function onDataProgressiveRead(chunk) {
+      var _this3 = this;
 
-  transportReady() {
-    this._readyCapability.resolve();
-  }
+      this._readyCapability.promise.then(function () {
+        var _iterator3 = _createForOfIteratorHelper(_this3._progressiveReadListeners),
+            _step3;
 
-  requestDataRange(begin, end) {
-    (0, _util.unreachable)("Abstract method PDFDataRangeTransport.requestDataRange");
-  }
+        try {
+          for (_iterator3.s(); !(_step3 = _iterator3.n()).done;) {
+            var listener = _step3.value;
+            listener(chunk);
+          }
+        } catch (err) {
+          _iterator3.e(err);
+        } finally {
+          _iterator3.f();
+        }
+      });
+    }
+  }, {
+    key: "onDataProgressiveDone",
+    value: function onDataProgressiveDone() {
+      var _this4 = this;
 
-  abort() {}
+      this._readyCapability.promise.then(function () {
+        var _iterator4 = _createForOfIteratorHelper(_this4._progressiveDoneListeners),
+            _step4;
 
-}
+        try {
+          for (_iterator4.s(); !(_step4 = _iterator4.n()).done;) {
+            var listener = _step4.value;
+            listener();
+          }
+        } catch (err) {
+          _iterator4.e(err);
+        } finally {
+          _iterator4.f();
+        }
+      });
+    }
+  }, {
+    key: "transportReady",
+    value: function transportReady() {
+      this._readyCapability.resolve();
+    }
+  }, {
+    key: "requestDataRange",
+    value: function requestDataRange(begin, end) {
+      (0, _util.unreachable)("Abstract method PDFDataRangeTransport.requestDataRange");
+    }
+  }, {
+    key: "abort",
+    value: function abort() {}
+  }]);
+
+  return PDFDataRangeTransport;
+}();
 
 exports.PDFDataRangeTransport = PDFDataRangeTransport;
 
-class PDFDocumentProxy {
-  constructor(pdfInfo, transport) {
+var PDFDocumentProxy = /*#__PURE__*/function () {
+  function PDFDocumentProxy(pdfInfo, transport) {
+    _classCallCheck(this, PDFDocumentProxy);
+
     this._pdfInfo = pdfInfo;
     this._transport = transport;
   }
 
-  get numPages() {
-    return this._pdfInfo.numPages;
-  }
-
-  get fingerprint() {
-    return this._pdfInfo.fingerprint;
-  }
-
-  getPage(pageNumber) {
-    return this._transport.getPage(pageNumber);
-  }
-
-  getPageIndex(ref) {
-    return this._transport.getPageIndex(ref);
-  }
-
-  getDestinations() {
-    return this._transport.getDestinations();
-  }
-
-  getDestination(id) {
-    return this._transport.getDestination(id);
-  }
-
-  getPageLabels() {
-    return this._transport.getPageLabels();
-  }
-
-  getPageLayout() {
-    return this._transport.getPageLayout();
-  }
-
-  getPageMode() {
-    return this._transport.getPageMode();
-  }
-
-  getViewerPreferences() {
-    return this._transport.getViewerPreferences();
-  }
-
-  getOpenAction() {
-    return this._transport.getOpenAction();
-  }
-
-  getOpenActionDestination() {
-    (0, _display_utils.deprecated)("getOpenActionDestination, use getOpenAction instead.");
-    return this.getOpenAction().then(function (openAction) {
-      return openAction && openAction.dest ? openAction.dest : null;
-    });
-  }
-
-  getAttachments() {
-    return this._transport.getAttachments();
-  }
-
-  getJavaScript() {
-    return this._transport.getJavaScript();
-  }
-
-  getOutline() {
-    return this._transport.getOutline();
-  }
-
-  getPermissions() {
-    return this._transport.getPermissions();
-  }
-
-  getMetadata() {
-    return this._transport.getMetadata();
-  }
-
-  getData() {
-    return this._transport.getData();
-  }
-
-  getDownloadInfo() {
-    return this._transport.downloadInfoCapability.promise;
-  }
-
-  getStats() {
-    return this._transport.getStats();
-  }
-
-  cleanup() {
-    return this._transport.startCleanup();
-  }
-
-  destroy() {
-    return this.loadingTask.destroy();
-  }
-
-  get loadingParams() {
-    return this._transport.loadingParams;
-  }
+  _createClass(PDFDocumentProxy, [{
+    key: "getPage",
+    value: function getPage(pageNumber) {
+      return this._transport.getPage(pageNumber);
+    }
+  }, {
+    key: "getPageIndex",
+    value: function getPageIndex(ref) {
+      return this._transport.getPageIndex(ref);
+    }
+  }, {
+    key: "getDestinations",
+    value: function getDestinations() {
+      return this._transport.getDestinations();
+    }
+  }, {
+    key: "getDestination",
+    value: function getDestination(id) {
+      return this._transport.getDestination(id);
+    }
+  }, {
+    key: "getPageLabels",
+    value: function getPageLabels() {
+      return this._transport.getPageLabels();
+    }
+  }, {
+    key: "getPageLayout",
+    value: function getPageLayout() {
+      return this._transport.getPageLayout();
+    }
+  }, {
+    key: "getPageMode",
+    value: function getPageMode() {
+      return this._transport.getPageMode();
+    }
+  }, {
+    key: "getViewerPreferences",
+    value: function getViewerPreferences() {
+      return this._transport.getViewerPreferences();
+    }
+  }, {
+    key: "getOpenAction",
+    value: function getOpenAction() {
+      return this._transport.getOpenAction();
+    }
+  }, {
+    key: "getOpenActionDestination",
+    value: function getOpenActionDestination() {
+      (0, _display_utils.deprecated)("getOpenActionDestination, use getOpenAction instead.");
+      return this.getOpenAction().then(function (openAction) {
+        return openAction && openAction.dest ? openAction.dest : null;
+      });
+    }
+  }, {
+    key: "getAttachments",
+    value: function getAttachments() {
+      return this._transport.getAttachments();
+    }
+  }, {
+    key: "getJavaScript",
+    value: function getJavaScript() {
+      return this._transport.getJavaScript();
+    }
+  }, {
+    key: "getOutline",
+    value: function getOutline() {
+      return this._transport.getOutline();
+    }
+  }, {
+    key: "getPermissions",
+    value: function getPermissions() {
+      return this._transport.getPermissions();
+    }
+  }, {
+    key: "getMetadata",
+    value: function getMetadata() {
+      return this._transport.getMetadata();
+    }
+  }, {
+    key: "getData",
+    value: function getData() {
+      return this._transport.getData();
+    }
+  }, {
+    key: "getDownloadInfo",
+    value: function getDownloadInfo() {
+      return this._transport.downloadInfoCapability.promise;
+    }
+  }, {
+    key: "getStats",
+    value: function getStats() {
+      return this._transport.getStats();
+    }
+  }, {
+    key: "cleanup",
+    value: function cleanup() {
+      return this._transport.startCleanup();
+    }
+  }, {
+    key: "destroy",
+    value: function destroy() {
+      return this.loadingTask.destroy();
+    }
+  }, {
+    key: "numPages",
+    get: function get() {
+      return this._pdfInfo.numPages;
+    }
+  }, {
+    key: "fingerprint",
+    get: function get() {
+      return this._pdfInfo.fingerprint;
+    }
+  }, {
+    key: "loadingParams",
+    get: function get() {
+      return this._transport.loadingParams;
+    }
+  }, {
+    key: "loadingTask",
+    get: function get() {
+      return this._transport.loadingTask;
+    }
+  }]);
+
+  return PDFDocumentProxy;
+}();
 
-  get loadingTask() {
-    return this._transport.loadingTask;
-  }
+exports.PDFDocumentProxy = PDFDocumentProxy;
 
-}
+var PDFPageProxy = /*#__PURE__*/function () {
+  function PDFPageProxy(pageIndex, pageInfo, transport) {
+    var pdfBug = arguments.length > 3 && arguments[3] !== undefined ? arguments[3] : false;
 
-exports.PDFDocumentProxy = PDFDocumentProxy;
+    _classCallCheck(this, PDFPageProxy);
 
-class PDFPageProxy {
-  constructor(pageIndex, pageInfo, transport, pdfBug = false) {
     this._pageIndex = pageIndex;
     this._pageInfo = pageInfo;
     this._transport = transport;
@@ -2186,593 +12673,661 @@ class PDFPageProxy {
     this.destroyed = false;
   }
 
-  get pageNumber() {
-    return this._pageIndex + 1;
-  }
+  _createClass(PDFPageProxy, [{
+    key: "getViewport",
+    value: function getViewport() {
+      var _ref3 = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {},
+          scale = _ref3.scale,
+          _ref3$rotation = _ref3.rotation,
+          rotation = _ref3$rotation === void 0 ? this.rotate : _ref3$rotation,
+          _ref3$offsetX = _ref3.offsetX,
+          offsetX = _ref3$offsetX === void 0 ? 0 : _ref3$offsetX,
+          _ref3$offsetY = _ref3.offsetY,
+          offsetY = _ref3$offsetY === void 0 ? 0 : _ref3$offsetY,
+          _ref3$dontFlip = _ref3.dontFlip,
+          dontFlip = _ref3$dontFlip === void 0 ? false : _ref3$dontFlip;
+
+      return new _display_utils.PageViewport({
+        viewBox: this.view,
+        scale: scale,
+        rotation: rotation,
+        offsetX: offsetX,
+        offsetY: offsetY,
+        dontFlip: dontFlip
+      });
+    }
+  }, {
+    key: "getAnnotations",
+    value: function getAnnotations() {
+      var _ref4 = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {},
+          _ref4$intent = _ref4.intent,
+          intent = _ref4$intent === void 0 ? null : _ref4$intent;
+
+      if (!this.annotationsPromise || this.annotationsIntent !== intent) {
+        this.annotationsPromise = this._transport.getAnnotations(this._pageIndex, intent);
+        this.annotationsIntent = intent;
+      }
+
+      return this.annotationsPromise;
+    }
+  }, {
+    key: "render",
+    value: function render(_ref5) {
+      var _this5 = this;
+
+      var canvasContext = _ref5.canvasContext,
+          viewport = _ref5.viewport,
+          _ref5$intent = _ref5.intent,
+          intent = _ref5$intent === void 0 ? "display" : _ref5$intent,
+          _ref5$enableWebGL = _ref5.enableWebGL,
+          enableWebGL = _ref5$enableWebGL === void 0 ? false : _ref5$enableWebGL,
+          _ref5$renderInteracti = _ref5.renderInteractiveForms,
+          renderInteractiveForms = _ref5$renderInteracti === void 0 ? false : _ref5$renderInteracti,
+          _ref5$transform = _ref5.transform,
+          transform = _ref5$transform === void 0 ? null : _ref5$transform,
+          _ref5$imageLayer = _ref5.imageLayer,
+          imageLayer = _ref5$imageLayer === void 0 ? null : _ref5$imageLayer,
+          _ref5$canvasFactory = _ref5.canvasFactory,
+          canvasFactory = _ref5$canvasFactory === void 0 ? null : _ref5$canvasFactory,
+          _ref5$background = _ref5.background,
+          background = _ref5$background === void 0 ? null : _ref5$background;
 
-  get rotate() {
-    return this._pageInfo.rotate;
-  }
+      if (this._stats) {
+        this._stats.time("Overall");
+      }
 
-  get ref() {
-    return this._pageInfo.ref;
-  }
+      var renderingIntent = intent === "print" ? "print" : "display";
+      this.pendingCleanup = false;
 
-  get userUnit() {
-    return this._pageInfo.userUnit;
-  }
+      if (!this.intentStates[renderingIntent]) {
+        this.intentStates[renderingIntent] = Object.create(null);
+      }
 
-  get view() {
-    return this._pageInfo.view;
-  }
+      var intentState = this.intentStates[renderingIntent];
 
-  getViewport({
-    scale,
-    rotation = this.rotate,
-    offsetX = 0,
-    offsetY = 0,
-    dontFlip = false
-  } = {}) {
-    return new _display_utils.PageViewport({
-      viewBox: this.view,
-      scale,
-      rotation,
-      offsetX,
-      offsetY,
-      dontFlip
-    });
-  }
+      if (intentState.streamReaderCancelTimeout) {
+        clearTimeout(intentState.streamReaderCancelTimeout);
+        intentState.streamReaderCancelTimeout = null;
+      }
 
-  getAnnotations({
-    intent = null
-  } = {}) {
-    if (!this.annotationsPromise || this.annotationsIntent !== intent) {
-      this.annotationsPromise = this._transport.getAnnotations(this._pageIndex, intent);
-      this.annotationsIntent = intent;
-    }
+      var canvasFactoryInstance = canvasFactory || new _display_utils.DOMCanvasFactory();
+      var webGLContext = new _webgl.WebGLContext({
+        enable: enableWebGL
+      });
 
-    return this.annotationsPromise;
-  }
+      if (!intentState.displayReadyCapability) {
+        intentState.displayReadyCapability = (0, _util.createPromiseCapability)();
+        intentState.operatorList = {
+          fnArray: [],
+          argsArray: [],
+          lastChunk: false
+        };
 
-  render({
-    canvasContext,
-    viewport,
-    intent = "display",
-    enableWebGL = false,
-    renderInteractiveForms = false,
-    transform = null,
-    imageLayer = null,
-    canvasFactory = null,
-    background = null
-  }) {
-    if (this._stats) {
-      this._stats.time("Overall");
-    }
+        if (this._stats) {
+          this._stats.time("Page Request");
+        }
 
-    const renderingIntent = intent === "print" ? "print" : "display";
-    this.pendingCleanup = false;
+        this._pumpOperatorList({
+          pageIndex: this._pageIndex,
+          intent: renderingIntent,
+          renderInteractiveForms: renderInteractiveForms === true
+        });
+      }
 
-    if (!this.intentStates[renderingIntent]) {
-      this.intentStates[renderingIntent] = Object.create(null);
-    }
+      var complete = function complete(error) {
+        var i = intentState.renderTasks.indexOf(internalRenderTask);
 
-    const intentState = this.intentStates[renderingIntent];
+        if (i >= 0) {
+          intentState.renderTasks.splice(i, 1);
+        }
 
-    if (intentState.streamReaderCancelTimeout) {
-      clearTimeout(intentState.streamReaderCancelTimeout);
-      intentState.streamReaderCancelTimeout = null;
-    }
+        if (_this5.cleanupAfterRender || renderingIntent === "print") {
+          _this5.pendingCleanup = true;
+        }
 
-    const canvasFactoryInstance = canvasFactory || new _display_utils.DOMCanvasFactory();
-    const webGLContext = new _webgl.WebGLContext({
-      enable: enableWebGL
-    });
+        _this5._tryCleanup();
 
-    if (!intentState.displayReadyCapability) {
-      intentState.displayReadyCapability = (0, _util.createPromiseCapability)();
-      intentState.operatorList = {
-        fnArray: [],
-        argsArray: [],
-        lastChunk: false
-      };
+        if (error) {
+          internalRenderTask.capability.reject(error);
 
-      if (this._stats) {
-        this._stats.time("Page Request");
-      }
+          _this5._abortOperatorList({
+            intentState: intentState,
+            reason: error
+          });
+        } else {
+          internalRenderTask.capability.resolve();
+        }
 
-      this._pumpOperatorList({
-        pageIndex: this._pageIndex,
-        intent: renderingIntent,
-        renderInteractiveForms: renderInteractiveForms === true
-      });
-    }
+        if (_this5._stats) {
+          _this5._stats.timeEnd("Rendering");
 
-    const complete = error => {
-      const i = intentState.renderTasks.indexOf(internalRenderTask);
+          _this5._stats.timeEnd("Overall");
+        }
+      };
 
-      if (i >= 0) {
-        intentState.renderTasks.splice(i, 1);
-      }
+      var internalRenderTask = new InternalRenderTask({
+        callback: complete,
+        params: {
+          canvasContext: canvasContext,
+          viewport: viewport,
+          transform: transform,
+          imageLayer: imageLayer,
+          background: background
+        },
+        objs: this.objs,
+        commonObjs: this.commonObjs,
+        operatorList: intentState.operatorList,
+        pageIndex: this._pageIndex,
+        canvasFactory: canvasFactoryInstance,
+        webGLContext: webGLContext,
+        useRequestAnimationFrame: renderingIntent !== "print",
+        pdfBug: this._pdfBug
+      });
 
-      if (this.cleanupAfterRender || renderingIntent === "print") {
-        this.pendingCleanup = true;
+      if (!intentState.renderTasks) {
+        intentState.renderTasks = [];
       }
 
-      this._tryCleanup();
+      intentState.renderTasks.push(internalRenderTask);
+      var renderTask = internalRenderTask.task;
+      intentState.displayReadyCapability.promise.then(function (transparency) {
+        if (_this5.pendingCleanup) {
+          complete();
+          return;
+        }
 
-      if (error) {
-        internalRenderTask.capability.reject(error);
+        if (_this5._stats) {
+          _this5._stats.time("Rendering");
+        }
 
-        this._abortOperatorList({
-          intentState,
-          reason: error
-        });
-      } else {
-        internalRenderTask.capability.resolve();
+        internalRenderTask.initializeGraphics(transparency);
+        internalRenderTask.operatorListChanged();
+      })["catch"](complete);
+      return renderTask;
+    }
+  }, {
+    key: "getOperatorList",
+    value: function getOperatorList() {
+      function operatorListChanged() {
+        if (intentState.operatorList.lastChunk) {
+          intentState.opListReadCapability.resolve(intentState.operatorList);
+          var i = intentState.renderTasks.indexOf(opListTask);
+
+          if (i >= 0) {
+            intentState.renderTasks.splice(i, 1);
+          }
+        }
       }
 
-      if (this._stats) {
-        this._stats.timeEnd("Rendering");
+      var renderingIntent = "oplist";
 
-        this._stats.timeEnd("Overall");
+      if (!this.intentStates[renderingIntent]) {
+        this.intentStates[renderingIntent] = Object.create(null);
       }
-    };
 
-    const internalRenderTask = new InternalRenderTask({
-      callback: complete,
-      params: {
-        canvasContext,
-        viewport,
-        transform,
-        imageLayer,
-        background
-      },
-      objs: this.objs,
-      commonObjs: this.commonObjs,
-      operatorList: intentState.operatorList,
-      pageIndex: this._pageIndex,
-      canvasFactory: canvasFactoryInstance,
-      webGLContext,
-      useRequestAnimationFrame: renderingIntent !== "print",
-      pdfBug: this._pdfBug
-    });
+      var intentState = this.intentStates[renderingIntent];
+      var opListTask;
 
-    if (!intentState.renderTasks) {
-      intentState.renderTasks = [];
-    }
+      if (!intentState.opListReadCapability) {
+        opListTask = {};
+        opListTask.operatorListChanged = operatorListChanged;
+        intentState.opListReadCapability = (0, _util.createPromiseCapability)();
+        intentState.renderTasks = [];
+        intentState.renderTasks.push(opListTask);
+        intentState.operatorList = {
+          fnArray: [],
+          argsArray: [],
+          lastChunk: false
+        };
 
-    intentState.renderTasks.push(internalRenderTask);
-    const renderTask = internalRenderTask.task;
-    intentState.displayReadyCapability.promise.then(transparency => {
-      if (this.pendingCleanup) {
-        complete();
-        return;
-      }
+        if (this._stats) {
+          this._stats.time("Page Request");
+        }
 
-      if (this._stats) {
-        this._stats.time("Rendering");
+        this._pumpOperatorList({
+          pageIndex: this._pageIndex,
+          intent: renderingIntent
+        });
       }
 
-      internalRenderTask.initializeGraphics(transparency);
-      internalRenderTask.operatorListChanged();
-    }).catch(complete);
-    return renderTask;
-  }
-
-  getOperatorList() {
-    function operatorListChanged() {
-      if (intentState.operatorList.lastChunk) {
-        intentState.opListReadCapability.resolve(intentState.operatorList);
-        const i = intentState.renderTasks.indexOf(opListTask);
+      return intentState.opListReadCapability.promise;
+    }
+  }, {
+    key: "streamTextContent",
+    value: function streamTextContent() {
+      var _ref6 = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {},
+          _ref6$normalizeWhites = _ref6.normalizeWhitespace,
+          normalizeWhitespace = _ref6$normalizeWhites === void 0 ? false : _ref6$normalizeWhites,
+          _ref6$disableCombineT = _ref6.disableCombineTextItems,
+          disableCombineTextItems = _ref6$disableCombineT === void 0 ? false : _ref6$disableCombineT;
 
-        if (i >= 0) {
-          intentState.renderTasks.splice(i, 1);
+      var TEXT_CONTENT_CHUNK_SIZE = 100;
+      return this._transport.messageHandler.sendWithStream("GetTextContent", {
+        pageIndex: this._pageIndex,
+        normalizeWhitespace: normalizeWhitespace === true,
+        combineTextItems: disableCombineTextItems !== true
+      }, {
+        highWaterMark: TEXT_CONTENT_CHUNK_SIZE,
+        size: function size(textContent) {
+          return textContent.items.length;
         }
-      }
+      });
     }
+  }, {
+    key: "getTextContent",
+    value: function getTextContent() {
+      var params = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {};
+      var readableStream = this.streamTextContent(params);
+      return new Promise(function (resolve, reject) {
+        function pump() {
+          reader.read().then(function (_ref7) {
+            var _textContent$items;
 
-    const renderingIntent = "oplist";
+            var value = _ref7.value,
+                done = _ref7.done;
 
-    if (!this.intentStates[renderingIntent]) {
-      this.intentStates[renderingIntent] = Object.create(null);
-    }
+            if (done) {
+              resolve(textContent);
+              return;
+            }
 
-    const intentState = this.intentStates[renderingIntent];
-    let opListTask;
+            Object.assign(textContent.styles, value.styles);
 
-    if (!intentState.opListReadCapability) {
-      opListTask = {};
-      opListTask.operatorListChanged = operatorListChanged;
-      intentState.opListReadCapability = (0, _util.createPromiseCapability)();
-      intentState.renderTasks = [];
-      intentState.renderTasks.push(opListTask);
-      intentState.operatorList = {
-        fnArray: [],
-        argsArray: [],
-        lastChunk: false
-      };
+            (_textContent$items = textContent.items).push.apply(_textContent$items, _toConsumableArray(value.items));
 
-      if (this._stats) {
-        this._stats.time("Page Request");
-      }
+            pump();
+          }, reject);
+        }
 
-      this._pumpOperatorList({
-        pageIndex: this._pageIndex,
-        intent: renderingIntent
+        var reader = readableStream.getReader();
+        var textContent = {
+          items: [],
+          styles: Object.create(null)
+        };
+        pump();
       });
     }
+  }, {
+    key: "_destroy",
+    value: function _destroy() {
+      var _this6 = this;
 
-    return intentState.opListReadCapability.promise;
-  }
+      this.destroyed = true;
+      this._transport.pageCache[this._pageIndex] = null;
+      var waitOn = [];
+      Object.keys(this.intentStates).forEach(function (intent) {
+        var intentState = _this6.intentStates[intent];
+
+        _this6._abortOperatorList({
+          intentState: intentState,
+          reason: new Error("Page was destroyed."),
+          force: true
+        });
 
-  streamTextContent({
-    normalizeWhitespace = false,
-    disableCombineTextItems = false
-  } = {}) {
-    const TEXT_CONTENT_CHUNK_SIZE = 100;
-    return this._transport.messageHandler.sendWithStream("GetTextContent", {
-      pageIndex: this._pageIndex,
-      normalizeWhitespace: normalizeWhitespace === true,
-      combineTextItems: disableCombineTextItems !== true
-    }, {
-      highWaterMark: TEXT_CONTENT_CHUNK_SIZE,
+        if (intent === "oplist") {
+          return;
+        }
+
+        intentState.renderTasks.forEach(function (renderTask) {
+          var renderCompleted = renderTask.capability.promise["catch"](function () {});
+          waitOn.push(renderCompleted);
+          renderTask.cancel();
+        });
+      });
+      this.objs.clear();
+      this.annotationsPromise = null;
+      this.pendingCleanup = false;
+      return Promise.all(waitOn);
+    }
+  }, {
+    key: "cleanup",
+    value: function cleanup() {
+      var resetStats = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : false;
+      this.pendingCleanup = true;
+      return this._tryCleanup(resetStats);
+    }
+  }, {
+    key: "_tryCleanup",
+    value: function _tryCleanup() {
+      var _this7 = this;
+
+      var resetStats = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : false;
+
+      if (!this.pendingCleanup || Object.keys(this.intentStates).some(function (intent) {
+        var intentState = _this7.intentStates[intent];
+        return intentState.renderTasks.length !== 0 || !intentState.operatorList.lastChunk;
+      })) {
+        return false;
+      }
+
+      Object.keys(this.intentStates).forEach(function (intent) {
+        delete _this7.intentStates[intent];
+      });
+      this.objs.clear();
+      this.annotationsPromise = null;
 
-      size(textContent) {
-        return textContent.items.length;
+      if (resetStats && this._stats) {
+        this._stats = new _display_utils.StatTimer();
       }
 
-    });
-  }
+      this.pendingCleanup = false;
+      return true;
+    }
+  }, {
+    key: "_startRenderPage",
+    value: function _startRenderPage(transparency, intent) {
+      var intentState = this.intentStates[intent];
 
-  getTextContent(params = {}) {
-    const readableStream = this.streamTextContent(params);
-    return new Promise(function (resolve, reject) {
-      function pump() {
-        reader.read().then(function ({
-          value,
-          done
-        }) {
-          if (done) {
-            resolve(textContent);
-            return;
-          }
+      if (!intentState) {
+        return;
+      }
 
-          Object.assign(textContent.styles, value.styles);
-          textContent.items.push(...value.items);
-          pump();
-        }, reject);
+      if (this._stats) {
+        this._stats.timeEnd("Page Request");
       }
 
-      const reader = readableStream.getReader();
-      const textContent = {
-        items: [],
-        styles: Object.create(null)
-      };
-      pump();
-    });
-  }
+      if (intentState.displayReadyCapability) {
+        intentState.displayReadyCapability.resolve(transparency);
+      }
+    }
+  }, {
+    key: "_renderPageChunk",
+    value: function _renderPageChunk(operatorListChunk, intentState) {
+      for (var i = 0, ii = operatorListChunk.length; i < ii; i++) {
+        intentState.operatorList.fnArray.push(operatorListChunk.fnArray[i]);
+        intentState.operatorList.argsArray.push(operatorListChunk.argsArray[i]);
+      }
 
-  _destroy() {
-    this.destroyed = true;
-    this._transport.pageCache[this._pageIndex] = null;
-    const waitOn = [];
-    Object.keys(this.intentStates).forEach(intent => {
-      const intentState = this.intentStates[intent];
+      intentState.operatorList.lastChunk = operatorListChunk.lastChunk;
 
-      this._abortOperatorList({
-        intentState,
-        reason: new Error("Page was destroyed."),
-        force: true
-      });
+      for (var _i2 = 0; _i2 < intentState.renderTasks.length; _i2++) {
+        intentState.renderTasks[_i2].operatorListChanged();
+      }
 
-      if (intent === "oplist") {
-        return;
+      if (operatorListChunk.lastChunk) {
+        this._tryCleanup();
       }
+    }
+  }, {
+    key: "_pumpOperatorList",
+    value: function _pumpOperatorList(args) {
+      var _this8 = this;
 
-      intentState.renderTasks.forEach(function (renderTask) {
-        const renderCompleted = renderTask.capability.promise.catch(function () {});
-        waitOn.push(renderCompleted);
-        renderTask.cancel();
-      });
-    });
-    this.objs.clear();
-    this.annotationsPromise = null;
-    this.pendingCleanup = false;
-    return Promise.all(waitOn);
-  }
+      (0, _util.assert)(args.intent, 'PDFPageProxy._pumpOperatorList: Expected "intent" argument.');
 
-  cleanup(resetStats = false) {
-    this.pendingCleanup = true;
-    return this._tryCleanup(resetStats);
-  }
+      var readableStream = this._transport.messageHandler.sendWithStream("GetOperatorList", args);
 
-  _tryCleanup(resetStats = false) {
-    if (!this.pendingCleanup || Object.keys(this.intentStates).some(intent => {
-      const intentState = this.intentStates[intent];
-      return intentState.renderTasks.length !== 0 || !intentState.operatorList.lastChunk;
-    })) {
-      return false;
-    }
+      var reader = readableStream.getReader();
+      var intentState = this.intentStates[args.intent];
+      intentState.streamReader = reader;
 
-    Object.keys(this.intentStates).forEach(intent => {
-      delete this.intentStates[intent];
-    });
-    this.objs.clear();
-    this.annotationsPromise = null;
+      var pump = function pump() {
+        reader.read().then(function (_ref8) {
+          var value = _ref8.value,
+              done = _ref8.done;
 
-    if (resetStats && this._stats) {
-      this._stats = new _display_utils.StatTimer();
-    }
+          if (done) {
+            intentState.streamReader = null;
+            return;
+          }
 
-    this.pendingCleanup = false;
-    return true;
-  }
+          if (_this8._transport.destroyed) {
+            return;
+          }
 
-  _startRenderPage(transparency, intent) {
-    const intentState = this.intentStates[intent];
+          _this8._renderPageChunk(value, intentState);
 
-    if (!intentState) {
-      return;
-    }
+          pump();
+        }, function (reason) {
+          intentState.streamReader = null;
 
-    if (this._stats) {
-      this._stats.timeEnd("Page Request");
-    }
+          if (_this8._transport.destroyed) {
+            return;
+          }
 
-    if (intentState.displayReadyCapability) {
-      intentState.displayReadyCapability.resolve(transparency);
-    }
-  }
+          if (intentState.operatorList) {
+            intentState.operatorList.lastChunk = true;
 
-  _renderPageChunk(operatorListChunk, intentState) {
-    for (let i = 0, ii = operatorListChunk.length; i < ii; i++) {
-      intentState.operatorList.fnArray.push(operatorListChunk.fnArray[i]);
-      intentState.operatorList.argsArray.push(operatorListChunk.argsArray[i]);
-    }
+            for (var i = 0; i < intentState.renderTasks.length; i++) {
+              intentState.renderTasks[i].operatorListChanged();
+            }
 
-    intentState.operatorList.lastChunk = operatorListChunk.lastChunk;
+            _this8._tryCleanup();
+          }
 
-    for (let i = 0; i < intentState.renderTasks.length; i++) {
-      intentState.renderTasks[i].operatorListChanged();
-    }
+          if (intentState.displayReadyCapability) {
+            intentState.displayReadyCapability.reject(reason);
+          } else if (intentState.opListReadCapability) {
+            intentState.opListReadCapability.reject(reason);
+          } else {
+            throw reason;
+          }
+        });
+      };
 
-    if (operatorListChunk.lastChunk) {
-      this._tryCleanup();
+      pump();
     }
-  }
-
-  _pumpOperatorList(args) {
-    (0, _util.assert)(args.intent, 'PDFPageProxy._pumpOperatorList: Expected "intent" argument.');
+  }, {
+    key: "_abortOperatorList",
+    value: function _abortOperatorList(_ref9) {
+      var _this9 = this;
 
-    const readableStream = this._transport.messageHandler.sendWithStream("GetOperatorList", args);
+      var intentState = _ref9.intentState,
+          reason = _ref9.reason,
+          _ref9$force = _ref9.force,
+          force = _ref9$force === void 0 ? false : _ref9$force;
+      (0, _util.assert)(reason instanceof Error || _typeof(reason) === "object" && reason !== null, 'PDFPageProxy._abortOperatorList: Expected "reason" argument.');
 
-    const reader = readableStream.getReader();
-    const intentState = this.intentStates[args.intent];
-    intentState.streamReader = reader;
-
-    const pump = () => {
-      reader.read().then(({
-        value,
-        done
-      }) => {
-        if (done) {
-          intentState.streamReader = null;
-          return;
-        }
+      if (!intentState.streamReader) {
+        return;
+      }
 
-        if (this._transport.destroyed) {
+      if (!force) {
+        if (intentState.renderTasks.length !== 0) {
           return;
         }
 
-        this._renderPageChunk(value, intentState);
-
-        pump();
-      }, reason => {
-        intentState.streamReader = null;
+        if (reason instanceof _display_utils.RenderingCancelledException) {
+          intentState.streamReaderCancelTimeout = setTimeout(function () {
+            _this9._abortOperatorList({
+              intentState: intentState,
+              reason: reason,
+              force: true
+            });
 
-        if (this._transport.destroyed) {
+            intentState.streamReaderCancelTimeout = null;
+          }, RENDERING_CANCELLED_TIMEOUT);
           return;
         }
+      }
 
-        if (intentState.operatorList) {
-          intentState.operatorList.lastChunk = true;
+      intentState.streamReader.cancel(new _util.AbortException(reason && reason.message));
+      intentState.streamReader = null;
 
-          for (let i = 0; i < intentState.renderTasks.length; i++) {
-            intentState.renderTasks[i].operatorListChanged();
-          }
+      if (this._transport.destroyed) {
+        return;
+      }
 
-          this._tryCleanup();
+      Object.keys(this.intentStates).some(function (intent) {
+        if (_this9.intentStates[intent] === intentState) {
+          delete _this9.intentStates[intent];
+          return true;
         }
 
-        if (intentState.displayReadyCapability) {
-          intentState.displayReadyCapability.reject(reason);
-        } else if (intentState.opListReadCapability) {
-          intentState.opListReadCapability.reject(reason);
-        } else {
-          throw reason;
-        }
+        return false;
       });
-    };
-
-    pump();
-  }
-
-  _abortOperatorList({
-    intentState,
-    reason,
-    force = false
-  }) {
-    (0, _util.assert)(reason instanceof Error || typeof reason === "object" && reason !== null, 'PDFPageProxy._abortOperatorList: Expected "reason" argument.');
-
-    if (!intentState.streamReader) {
-      return;
+      this.cleanup();
     }
-
-    if (!force) {
-      if (intentState.renderTasks.length !== 0) {
-        return;
-      }
-
-      if (reason instanceof _display_utils.RenderingCancelledException) {
-        intentState.streamReaderCancelTimeout = setTimeout(() => {
-          this._abortOperatorList({
-            intentState,
-            reason,
-            force: true
-          });
-
-          intentState.streamReaderCancelTimeout = null;
-        }, RENDERING_CANCELLED_TIMEOUT);
-        return;
-      }
+  }, {
+    key: "pageNumber",
+    get: function get() {
+      return this._pageIndex + 1;
     }
-
-    intentState.streamReader.cancel(new _util.AbortException(reason && reason.message));
-    intentState.streamReader = null;
-
-    if (this._transport.destroyed) {
-      return;
+  }, {
+    key: "rotate",
+    get: function get() {
+      return this._pageInfo.rotate;
     }
+  }, {
+    key: "ref",
+    get: function get() {
+      return this._pageInfo.ref;
+    }
+  }, {
+    key: "userUnit",
+    get: function get() {
+      return this._pageInfo.userUnit;
+    }
+  }, {
+    key: "view",
+    get: function get() {
+      return this._pageInfo.view;
+    }
+  }, {
+    key: "stats",
+    get: function get() {
+      return this._stats;
+    }
+  }]);
 
-    Object.keys(this.intentStates).some(intent => {
-      if (this.intentStates[intent] === intentState) {
-        delete this.intentStates[intent];
-        return true;
-      }
-
-      return false;
-    });
-    this.cleanup();
-  }
+  return PDFPageProxy;
+}();
 
-  get stats() {
-    return this._stats;
-  }
+exports.PDFPageProxy = PDFPageProxy;
 
-}
+var LoopbackPort = /*#__PURE__*/function () {
+  function LoopbackPort() {
+    var defer = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : true;
 
-exports.PDFPageProxy = PDFPageProxy;
+    _classCallCheck(this, LoopbackPort);
 
-class LoopbackPort {
-  constructor(defer = true) {
     this._listeners = [];
     this._defer = defer;
     this._deferred = Promise.resolve(undefined);
   }
 
-  postMessage(obj, transfers) {
-    function cloneValue(value) {
-      if (typeof value !== "object" || value === null) {
-        return value;
-      }
+  _createClass(LoopbackPort, [{
+    key: "postMessage",
+    value: function postMessage(obj, transfers) {
+      var _this10 = this;
 
-      if (cloned.has(value)) {
-        return cloned.get(value);
-      }
+      function cloneValue(value) {
+        if (_typeof(value) !== "object" || value === null) {
+          return value;
+        }
+
+        if (cloned.has(value)) {
+          return cloned.get(value);
+        }
 
-      let buffer, result;
+        var buffer, result;
 
-      if ((buffer = value.buffer) && (0, _util.isArrayBuffer)(buffer)) {
-        const transferable = transfers && transfers.includes(buffer);
+        if ((buffer = value.buffer) && (0, _util.isArrayBuffer)(buffer)) {
+          var transferable = transfers && transfers.includes(buffer);
 
-        if (transferable) {
-          result = new value.constructor(buffer, value.byteOffset, value.byteLength);
-        } else {
-          result = new value.constructor(value);
+          if (transferable) {
+            result = new value.constructor(buffer, value.byteOffset, value.byteLength);
+          } else {
+            result = new value.constructor(value);
+          }
+
+          cloned.set(value, result);
+          return result;
         }
 
+        result = Array.isArray(value) ? [] : {};
         cloned.set(value, result);
-        return result;
-      }
 
-      result = Array.isArray(value) ? [] : {};
-      cloned.set(value, result);
+        for (var i in value) {
+          var desc = void 0,
+              p = value;
 
-      for (const i in value) {
-        let desc,
-            p = value;
+          while (!(desc = Object.getOwnPropertyDescriptor(p, i))) {
+            p = Object.getPrototypeOf(p);
+          }
 
-        while (!(desc = Object.getOwnPropertyDescriptor(p, i))) {
-          p = Object.getPrototypeOf(p);
-        }
+          if (typeof desc.value === "undefined") {
+            continue;
+          }
 
-        if (typeof desc.value === "undefined") {
-          continue;
-        }
+          if (typeof desc.value === "function") {
+            if (value.hasOwnProperty && value.hasOwnProperty(i)) {
+              throw new Error("LoopbackPort.postMessage - cannot clone: ".concat(value[i]));
+            }
 
-        if (typeof desc.value === "function") {
-          if (value.hasOwnProperty && value.hasOwnProperty(i)) {
-            throw new Error(`LoopbackPort.postMessage - cannot clone: ${value[i]}`);
+            continue;
           }
 
-          continue;
+          result[i] = cloneValue(desc.value);
         }
 
-        result[i] = cloneValue(desc.value);
+        return result;
       }
 
-      return result;
-    }
-
-    if (!this._defer) {
-      this._listeners.forEach(listener => {
-        listener.call(this, {
-          data: obj
+      if (!this._defer) {
+        this._listeners.forEach(function (listener) {
+          listener.call(_this10, {
+            data: obj
+          });
         });
-      });
 
-      return;
-    }
+        return;
+      }
 
-    const cloned = new WeakMap();
-    const e = {
-      data: cloneValue(obj)
-    };
+      var cloned = new WeakMap();
+      var e = {
+        data: cloneValue(obj)
+      };
 
-    this._deferred.then(() => {
-      this._listeners.forEach(listener => {
-        listener.call(this, e);
+      this._deferred.then(function () {
+        _this10._listeners.forEach(function (listener) {
+          listener.call(_this10, e);
+        });
       });
-    });
-  }
-
-  addEventListener(name, listener) {
-    this._listeners.push(listener);
-  }
-
-  removeEventListener(name, listener) {
-    const i = this._listeners.indexOf(listener);
-
-    this._listeners.splice(i, 1);
-  }
+    }
+  }, {
+    key: "addEventListener",
+    value: function addEventListener(name, listener) {
+      this._listeners.push(listener);
+    }
+  }, {
+    key: "removeEventListener",
+    value: function removeEventListener(name, listener) {
+      var i = this._listeners.indexOf(listener);
 
-  terminate() {
-    this._listeners.length = 0;
-  }
+      this._listeners.splice(i, 1);
+    }
+  }, {
+    key: "terminate",
+    value: function terminate() {
+      this._listeners.length = 0;
+    }
+  }]);
 
-}
+  return LoopbackPort;
+}();
 
 exports.LoopbackPort = LoopbackPort;
 
-const PDFWorker = function PDFWorkerClosure() {
-  const pdfWorkerPorts = new WeakMap();
-  let isWorkerDisabled = false;
-  let fallbackWorkerSrc;
-  let nextFakeWorkerId = 0;
-  let fakeWorkerCapability;
+var PDFWorker = function PDFWorkerClosure() {
+  var pdfWorkerPorts = new WeakMap();
+  var isWorkerDisabled = false;
+  var fallbackWorkerSrc;
+  var nextFakeWorkerId = 0;
+  var fakeWorkerCapability;
 
   if (_is_node.isNodeJS && typeof require === "function") {
     isWorkerDisabled = true;
     fallbackWorkerSrc = "./pdf.worker.js";
-  } else if (typeof document === "object" && "currentScript" in document) {
-    const pdfjsFilePath = document.currentScript && document.currentScript.src;
+  } else if ((typeof document === "undefined" ? "undefined" : _typeof(document)) === "object" && "currentScript" in document) {
+    var pdfjsFilePath = document.currentScript && document.currentScript.src;
 
     if (pdfjsFilePath) {
       fallbackWorkerSrc = pdfjsFilePath.replace(/(\.(?:min\.)?js)(\?.*)?$/i, ".worker$1$2");
     }
   }
 
-  function getWorkerSrc() {
+  function _getWorkerSrc() {
     if (_worker_options.GlobalWorkerOptions.workerSrc) {
       return _worker_options.GlobalWorkerOptions.workerSrc;
     }
@@ -2789,7 +13344,7 @@ const PDFWorker = function PDFWorkerClosure() {
   }
 
   function getMainThreadWorkerMessageHandler() {
-    let mainWorkerMessageHandler;
+    var mainWorkerMessageHandler;
 
     try {
       mainWorkerMessageHandler = globalThis.pdfjsWorker && globalThis.pdfjsWorker.WorkerMessageHandler;
@@ -2805,37 +13360,72 @@ const PDFWorker = function PDFWorkerClosure() {
 
     fakeWorkerCapability = (0, _util.createPromiseCapability)();
 
-    const loader = async function () {
-      const mainWorkerMessageHandler = getMainThreadWorkerMessageHandler();
+    var loader = /*#__PURE__*/function () {
+      var _ref10 = _asyncToGenerator( /*#__PURE__*/_regenerator["default"].mark(function _callee() {
+        var mainWorkerMessageHandler, worker;
+        return _regenerator["default"].wrap(function _callee$(_context) {
+          while (1) {
+            switch (_context.prev = _context.next) {
+              case 0:
+                mainWorkerMessageHandler = getMainThreadWorkerMessageHandler();
+
+                if (!mainWorkerMessageHandler) {
+                  _context.next = 3;
+                  break;
+                }
 
-      if (mainWorkerMessageHandler) {
-        return mainWorkerMessageHandler;
-      }
+                return _context.abrupt("return", mainWorkerMessageHandler);
 
-      if (_is_node.isNodeJS && typeof require === "function") {
-        const worker = eval("require")(getWorkerSrc());
-        return worker.WorkerMessageHandler;
-      }
+              case 3:
+                if (!(_is_node.isNodeJS && typeof require === "function")) {
+                  _context.next = 6;
+                  break;
+                }
 
-      await (0, _display_utils.loadScript)(getWorkerSrc());
-      return window.pdfjsWorker.WorkerMessageHandler;
-    };
+                worker = eval("require")(_getWorkerSrc());
+                return _context.abrupt("return", worker.WorkerMessageHandler);
+
+              case 6:
+                _context.next = 8;
+                return (0, _display_utils.loadScript)(_getWorkerSrc());
+
+              case 8:
+                return _context.abrupt("return", window.pdfjsWorker.WorkerMessageHandler);
+
+              case 9:
+              case "end":
+                return _context.stop();
+            }
+          }
+        }, _callee);
+      }));
+
+      return function loader() {
+        return _ref10.apply(this, arguments);
+      };
+    }();
 
     loader().then(fakeWorkerCapability.resolve, fakeWorkerCapability.reject);
     return fakeWorkerCapability.promise;
   }
 
   function createCDNWrapper(url) {
-    const wrapper = "importScripts('" + url + "');";
+    var wrapper = "importScripts('" + url + "');";
     return URL.createObjectURL(new Blob([wrapper]));
   }
 
-  class PDFWorker {
-    constructor({
-      name = null,
-      port = null,
-      verbosity = (0, _util.getVerbosityLevel)()
-    } = {}) {
+  var PDFWorker = /*#__PURE__*/function () {
+    function PDFWorker() {
+      var _ref11 = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {},
+          _ref11$name = _ref11.name,
+          name = _ref11$name === void 0 ? null : _ref11$name,
+          _ref11$port = _ref11.port,
+          port = _ref11$port === void 0 ? null : _ref11$port,
+          _ref11$verbosity = _ref11.verbosity,
+          verbosity = _ref11$verbosity === void 0 ? (0, _util.getVerbosityLevel)() : _ref11$verbosity;
+
+      _classCallCheck(this, PDFWorker);
+
       if (port && pdfWorkerPorts.has(port)) {
         throw new Error("Cannot use more than one PDFWorker per port");
       }
@@ -2860,199 +13450,217 @@ const PDFWorker = function PDFWorkerClosure() {
       this._initialize();
     }
 
-    get promise() {
-      return this._readyCapability.promise;
-    }
+    _createClass(PDFWorker, [{
+      key: "_initializeFromPort",
+      value: function _initializeFromPort(port) {
+        this._port = port;
+        this._messageHandler = new _message_handler.MessageHandler("main", "worker", port);
 
-    get port() {
-      return this._port;
-    }
+        this._messageHandler.on("ready", function () {});
 
-    get messageHandler() {
-      return this._messageHandler;
-    }
+        this._readyCapability.resolve();
+      }
+    }, {
+      key: "_initialize",
+      value: function _initialize() {
+        var _this11 = this;
 
-    _initializeFromPort(port) {
-      this._port = port;
-      this._messageHandler = new _message_handler.MessageHandler("main", "worker", port);
+        if (typeof Worker !== "undefined" && !isWorkerDisabled && !getMainThreadWorkerMessageHandler()) {
+          var workerSrc = _getWorkerSrc();
 
-      this._messageHandler.on("ready", function () {});
+          try {
+            if (!(0, _util.isSameOrigin)(window.location.href, workerSrc)) {
+              workerSrc = createCDNWrapper(new URL(workerSrc, window.location).href);
+            }
 
-      this._readyCapability.resolve();
-    }
+            var worker = new Worker(workerSrc);
+            var messageHandler = new _message_handler.MessageHandler("main", "worker", worker);
 
-    _initialize() {
-      if (typeof Worker !== "undefined" && !isWorkerDisabled && !getMainThreadWorkerMessageHandler()) {
-        let workerSrc = getWorkerSrc();
+            var terminateEarly = function terminateEarly() {
+              worker.removeEventListener("error", onWorkerError);
+              messageHandler.destroy();
+              worker.terminate();
 
-        try {
-          if (!(0, _util.isSameOrigin)(window.location.href, workerSrc)) {
-            workerSrc = createCDNWrapper(new URL(workerSrc, window.location).href);
-          }
+              if (_this11.destroyed) {
+                _this11._readyCapability.reject(new Error("Worker was destroyed"));
+              } else {
+                _this11._setupFakeWorker();
+              }
+            };
 
-          const worker = new Worker(workerSrc);
-          const messageHandler = new _message_handler.MessageHandler("main", "worker", worker);
+            var onWorkerError = function onWorkerError() {
+              if (!_this11._webWorker) {
+                terminateEarly();
+              }
+            };
 
-          const terminateEarly = () => {
-            worker.removeEventListener("error", onWorkerError);
-            messageHandler.destroy();
-            worker.terminate();
+            worker.addEventListener("error", onWorkerError);
+            messageHandler.on("test", function (data) {
+              worker.removeEventListener("error", onWorkerError);
 
-            if (this.destroyed) {
-              this._readyCapability.reject(new Error("Worker was destroyed"));
-            } else {
-              this._setupFakeWorker();
-            }
-          };
+              if (_this11.destroyed) {
+                terminateEarly();
+                return;
+              }
 
-          const onWorkerError = () => {
-            if (!this._webWorker) {
-              terminateEarly();
-            }
-          };
+              if (data) {
+                _this11._messageHandler = messageHandler;
+                _this11._port = worker;
+                _this11._webWorker = worker;
 
-          worker.addEventListener("error", onWorkerError);
-          messageHandler.on("test", data => {
-            worker.removeEventListener("error", onWorkerError);
+                if (!data.supportTransfers) {
+                  _this11.postMessageTransfers = false;
+                }
 
-            if (this.destroyed) {
-              terminateEarly();
-              return;
-            }
+                _this11._readyCapability.resolve();
 
-            if (data) {
-              this._messageHandler = messageHandler;
-              this._port = worker;
-              this._webWorker = worker;
+                messageHandler.send("configure", {
+                  verbosity: _this11.verbosity
+                });
+              } else {
+                _this11._setupFakeWorker();
 
-              if (!data.supportTransfers) {
-                this.postMessageTransfers = false;
+                messageHandler.destroy();
+                worker.terminate();
               }
+            });
+            messageHandler.on("ready", function (data) {
+              worker.removeEventListener("error", onWorkerError);
 
-              this._readyCapability.resolve();
-
-              messageHandler.send("configure", {
-                verbosity: this.verbosity
-              });
-            } else {
-              this._setupFakeWorker();
-
-              messageHandler.destroy();
-              worker.terminate();
-            }
-          });
-          messageHandler.on("ready", data => {
-            worker.removeEventListener("error", onWorkerError);
-
-            if (this.destroyed) {
-              terminateEarly();
-              return;
-            }
+              if (_this11.destroyed) {
+                terminateEarly();
+                return;
+              }
 
-            try {
-              sendTest();
-            } catch (e) {
-              this._setupFakeWorker();
-            }
-          });
+              try {
+                sendTest();
+              } catch (e) {
+                _this11._setupFakeWorker();
+              }
+            });
 
-          const sendTest = () => {
-            const testObj = new Uint8Array([this.postMessageTransfers ? 255 : 0]);
+            var sendTest = function sendTest() {
+              var testObj = new Uint8Array([_this11.postMessageTransfers ? 255 : 0]);
 
-            try {
-              messageHandler.send("test", testObj, [testObj.buffer]);
-            } catch (ex) {
-              (0, _util.warn)("Cannot use postMessage transfers.");
-              testObj[0] = 0;
-              messageHandler.send("test", testObj);
-            }
-          };
+              try {
+                messageHandler.send("test", testObj, [testObj.buffer]);
+              } catch (ex) {
+                (0, _util.warn)("Cannot use postMessage transfers.");
+                testObj[0] = 0;
+                messageHandler.send("test", testObj);
+              }
+            };
 
-          sendTest();
-          return;
-        } catch (e) {
-          (0, _util.info)("The worker has been disabled.");
+            sendTest();
+            return;
+          } catch (e) {
+            (0, _util.info)("The worker has been disabled.");
+          }
         }
-      }
 
-      this._setupFakeWorker();
-    }
-
-    _setupFakeWorker() {
-      if (!isWorkerDisabled) {
-        (0, _util.warn)("Setting up fake worker.");
-        isWorkerDisabled = true;
+        this._setupFakeWorker();
       }
+    }, {
+      key: "_setupFakeWorker",
+      value: function _setupFakeWorker() {
+        var _this12 = this;
 
-      setupFakeWorkerGlobal().then(WorkerMessageHandler => {
-        if (this.destroyed) {
-          this._readyCapability.reject(new Error("Worker was destroyed"));
-
-          return;
+        if (!isWorkerDisabled) {
+          (0, _util.warn)("Setting up fake worker.");
+          isWorkerDisabled = true;
         }
 
-        const port = new LoopbackPort();
-        this._port = port;
-        const id = "fake" + nextFakeWorkerId++;
-        const workerHandler = new _message_handler.MessageHandler(id + "_worker", id, port);
-        WorkerMessageHandler.setup(workerHandler, port);
-        const messageHandler = new _message_handler.MessageHandler(id, id + "_worker", port);
-        this._messageHandler = messageHandler;
-
-        this._readyCapability.resolve();
+        setupFakeWorkerGlobal().then(function (WorkerMessageHandler) {
+          if (_this12.destroyed) {
+            _this12._readyCapability.reject(new Error("Worker was destroyed"));
 
-        messageHandler.send("configure", {
-          verbosity: this.verbosity
-        });
-      }).catch(reason => {
-        this._readyCapability.reject(new Error(`Setting up fake worker failed: "${reason.message}".`));
-      });
-    }
+            return;
+          }
 
-    destroy() {
-      this.destroyed = true;
+          var port = new LoopbackPort();
+          _this12._port = port;
+          var id = "fake" + nextFakeWorkerId++;
+          var workerHandler = new _message_handler.MessageHandler(id + "_worker", id, port);
+          WorkerMessageHandler.setup(workerHandler, port);
+          var messageHandler = new _message_handler.MessageHandler(id, id + "_worker", port);
+          _this12._messageHandler = messageHandler;
 
-      if (this._webWorker) {
-        this._webWorker.terminate();
+          _this12._readyCapability.resolve();
 
-        this._webWorker = null;
+          messageHandler.send("configure", {
+            verbosity: _this12.verbosity
+          });
+        })["catch"](function (reason) {
+          _this12._readyCapability.reject(new Error("Setting up fake worker failed: \"".concat(reason.message, "\".")));
+        });
       }
+    }, {
+      key: "destroy",
+      value: function destroy() {
+        this.destroyed = true;
 
-      pdfWorkerPorts.delete(this._port);
-      this._port = null;
+        if (this._webWorker) {
+          this._webWorker.terminate();
 
-      if (this._messageHandler) {
-        this._messageHandler.destroy();
+          this._webWorker = null;
+        }
 
-        this._messageHandler = null;
-      }
-    }
+        pdfWorkerPorts["delete"](this._port);
+        this._port = null;
 
-    static fromPort(params) {
-      if (!params || !params.port) {
-        throw new Error("PDFWorker.fromPort - invalid method signature.");
-      }
+        if (this._messageHandler) {
+          this._messageHandler.destroy();
 
-      if (pdfWorkerPorts.has(params.port)) {
-        return pdfWorkerPorts.get(params.port);
+          this._messageHandler = null;
+        }
       }
+    }, {
+      key: "promise",
+      get: function get() {
+        return this._readyCapability.promise;
+      }
+    }, {
+      key: "port",
+      get: function get() {
+        return this._port;
+      }
+    }, {
+      key: "messageHandler",
+      get: function get() {
+        return this._messageHandler;
+      }
+    }], [{
+      key: "fromPort",
+      value: function fromPort(params) {
+        if (!params || !params.port) {
+          throw new Error("PDFWorker.fromPort - invalid method signature.");
+        }
 
-      return new PDFWorker(params);
-    }
+        if (pdfWorkerPorts.has(params.port)) {
+          return pdfWorkerPorts.get(params.port);
+        }
 
-    static getWorkerSrc() {
-      return getWorkerSrc();
-    }
+        return new PDFWorker(params);
+      }
+    }, {
+      key: "getWorkerSrc",
+      value: function getWorkerSrc() {
+        return _getWorkerSrc();
+      }
+    }]);
 
-  }
+    return PDFWorker;
+  }();
 
   return PDFWorker;
 }();
 
 exports.PDFWorker = PDFWorker;
 
-class WorkerTransport {
-  constructor(messageHandler, loadingTask, networkStream, params) {
+var WorkerTransport = /*#__PURE__*/function () {
+  function WorkerTransport(messageHandler, loadingTask, networkStream, params) {
+    _classCallCheck(this, WorkerTransport);
+
     this.messageHandler = messageHandler;
     this.loadingTask = loadingTask;
     this.commonObjs = new PDFObjects();
@@ -3077,577 +13685,647 @@ class WorkerTransport {
     this.setupMessageHandler();
   }
 
-  destroy() {
-    if (this.destroyCapability) {
-      return this.destroyCapability.promise;
-    }
+  _createClass(WorkerTransport, [{
+    key: "destroy",
+    value: function destroy() {
+      var _this13 = this;
 
-    this.destroyed = true;
-    this.destroyCapability = (0, _util.createPromiseCapability)();
+      if (this.destroyCapability) {
+        return this.destroyCapability.promise;
+      }
 
-    if (this._passwordCapability) {
-      this._passwordCapability.reject(new Error("Worker was destroyed during onPassword callback"));
-    }
+      this.destroyed = true;
+      this.destroyCapability = (0, _util.createPromiseCapability)();
 
-    const waitOn = [];
-    this.pageCache.forEach(function (page) {
-      if (page) {
-        waitOn.push(page._destroy());
+      if (this._passwordCapability) {
+        this._passwordCapability.reject(new Error("Worker was destroyed during onPassword callback"));
       }
-    });
-    this.pageCache.length = 0;
-    this.pagePromises.length = 0;
-    const terminated = this.messageHandler.sendWithPromise("Terminate", null);
-    waitOn.push(terminated);
-    Promise.all(waitOn).then(() => {
-      this.fontLoader.clear();
 
-      if (this._networkStream) {
-        this._networkStream.cancelAllRequests(new _util.AbortException("Worker was terminated."));
-      }
+      var waitOn = [];
+      this.pageCache.forEach(function (page) {
+        if (page) {
+          waitOn.push(page._destroy());
+        }
+      });
+      this.pageCache.length = 0;
+      this.pagePromises.length = 0;
+      var terminated = this.messageHandler.sendWithPromise("Terminate", null);
+      waitOn.push(terminated);
+      Promise.all(waitOn).then(function () {
+        _this13.fontLoader.clear();
+
+        if (_this13._networkStream) {
+          _this13._networkStream.cancelAllRequests(new _util.AbortException("Worker was terminated."));
+        }
 
-      if (this.messageHandler) {
-        this.messageHandler.destroy();
-        this.messageHandler = null;
-      }
+        if (_this13.messageHandler) {
+          _this13.messageHandler.destroy();
 
-      this.destroyCapability.resolve();
-    }, this.destroyCapability.reject);
-    return this.destroyCapability.promise;
-  }
+          _this13.messageHandler = null;
+        }
+
+        _this13.destroyCapability.resolve();
+      }, this.destroyCapability.reject);
+      return this.destroyCapability.promise;
+    }
+  }, {
+    key: "setupMessageHandler",
+    value: function setupMessageHandler() {
+      var _this14 = this;
+
+      var messageHandler = this.messageHandler,
+          loadingTask = this.loadingTask;
+      messageHandler.on("GetReader", function (data, sink) {
+        (0, _util.assert)(_this14._networkStream, "GetReader - no `IPDFStream` instance available.");
+        _this14._fullReader = _this14._networkStream.getFullReader();
+
+        _this14._fullReader.onProgress = function (evt) {
+          _this14._lastProgress = {
+            loaded: evt.loaded,
+            total: evt.total
+          };
+        };
 
-  setupMessageHandler() {
-    const {
-      messageHandler,
-      loadingTask
-    } = this;
-    messageHandler.on("GetReader", (data, sink) => {
-      (0, _util.assert)(this._networkStream, "GetReader - no `IPDFStream` instance available.");
-      this._fullReader = this._networkStream.getFullReader();
+        sink.onPull = function () {
+          _this14._fullReader.read().then(function (_ref12) {
+            var value = _ref12.value,
+                done = _ref12.done;
 
-      this._fullReader.onProgress = evt => {
-        this._lastProgress = {
-          loaded: evt.loaded,
-          total: evt.total
+            if (done) {
+              sink.close();
+              return;
+            }
+
+            (0, _util.assert)((0, _util.isArrayBuffer)(value), "GetReader - expected an ArrayBuffer.");
+            sink.enqueue(new Uint8Array(value), 1, [value]);
+          })["catch"](function (reason) {
+            sink.error(reason);
+          });
         };
-      };
 
-      sink.onPull = () => {
-        this._fullReader.read().then(function ({
-          value,
-          done
-        }) {
-          if (done) {
-            sink.close();
-            return;
+        sink.onCancel = function (reason) {
+          _this14._fullReader.cancel(reason);
+        };
+      });
+      messageHandler.on("ReaderHeadersReady", function (data) {
+        var headersCapability = (0, _util.createPromiseCapability)();
+        var fullReader = _this14._fullReader;
+        fullReader.headersReady.then(function () {
+          if (!fullReader.isStreamingSupported || !fullReader.isRangeSupported) {
+            if (_this14._lastProgress && loadingTask.onProgress) {
+              loadingTask.onProgress(_this14._lastProgress);
+            }
+
+            fullReader.onProgress = function (evt) {
+              if (loadingTask.onProgress) {
+                loadingTask.onProgress({
+                  loaded: evt.loaded,
+                  total: evt.total
+                });
+              }
+            };
           }
 
-          (0, _util.assert)((0, _util.isArrayBuffer)(value), "GetReader - expected an ArrayBuffer.");
-          sink.enqueue(new Uint8Array(value), 1, [value]);
-        }).catch(reason => {
-          sink.error(reason);
-        });
-      };
+          headersCapability.resolve({
+            isStreamingSupported: fullReader.isStreamingSupported,
+            isRangeSupported: fullReader.isRangeSupported,
+            contentLength: fullReader.contentLength
+          });
+        }, headersCapability.reject);
+        return headersCapability.promise;
+      });
+      messageHandler.on("GetRangeReader", function (data, sink) {
+        (0, _util.assert)(_this14._networkStream, "GetRangeReader - no `IPDFStream` instance available.");
 
-      sink.onCancel = reason => {
-        this._fullReader.cancel(reason);
-      };
-    });
-    messageHandler.on("ReaderHeadersReady", data => {
-      const headersCapability = (0, _util.createPromiseCapability)();
-      const fullReader = this._fullReader;
-      fullReader.headersReady.then(() => {
-        if (!fullReader.isStreamingSupported || !fullReader.isRangeSupported) {
-          if (this._lastProgress && loadingTask.onProgress) {
-            loadingTask.onProgress(this._lastProgress);
-          }
+        var rangeReader = _this14._networkStream.getRangeReader(data.begin, data.end);
 
-          fullReader.onProgress = evt => {
-            if (loadingTask.onProgress) {
-              loadingTask.onProgress({
-                loaded: evt.loaded,
-                total: evt.total
-              });
-            }
-          };
+        if (!rangeReader) {
+          sink.close();
+          return;
         }
 
-        headersCapability.resolve({
-          isStreamingSupported: fullReader.isStreamingSupported,
-          isRangeSupported: fullReader.isRangeSupported,
-          contentLength: fullReader.contentLength
-        });
-      }, headersCapability.reject);
-      return headersCapability.promise;
-    });
-    messageHandler.on("GetRangeReader", (data, sink) => {
-      (0, _util.assert)(this._networkStream, "GetRangeReader - no `IPDFStream` instance available.");
+        sink.onPull = function () {
+          rangeReader.read().then(function (_ref13) {
+            var value = _ref13.value,
+                done = _ref13.done;
 
-      const rangeReader = this._networkStream.getRangeReader(data.begin, data.end);
+            if (done) {
+              sink.close();
+              return;
+            }
 
-      if (!rangeReader) {
-        sink.close();
-        return;
-      }
+            (0, _util.assert)((0, _util.isArrayBuffer)(value), "GetRangeReader - expected an ArrayBuffer.");
+            sink.enqueue(new Uint8Array(value), 1, [value]);
+          })["catch"](function (reason) {
+            sink.error(reason);
+          });
+        };
 
-      sink.onPull = () => {
-        rangeReader.read().then(function ({
-          value,
-          done
-        }) {
-          if (done) {
-            sink.close();
-            return;
-          }
+        sink.onCancel = function (reason) {
+          rangeReader.cancel(reason);
+        };
+      });
+      messageHandler.on("GetDoc", function (_ref14) {
+        var pdfInfo = _ref14.pdfInfo;
+        _this14._numPages = pdfInfo.numPages;
 
-          (0, _util.assert)((0, _util.isArrayBuffer)(value), "GetRangeReader - expected an ArrayBuffer.");
-          sink.enqueue(new Uint8Array(value), 1, [value]);
-        }).catch(reason => {
-          sink.error(reason);
-        });
-      };
+        loadingTask._capability.resolve(new PDFDocumentProxy(pdfInfo, _this14));
+      });
+      messageHandler.on("DocException", function (ex) {
+        var reason;
 
-      sink.onCancel = reason => {
-        rangeReader.cancel(reason);
-      };
-    });
-    messageHandler.on("GetDoc", ({
-      pdfInfo
-    }) => {
-      this._numPages = pdfInfo.numPages;
+        switch (ex.name) {
+          case "PasswordException":
+            reason = new _util.PasswordException(ex.message, ex.code);
+            break;
 
-      loadingTask._capability.resolve(new PDFDocumentProxy(pdfInfo, this));
-    });
-    messageHandler.on("DocException", function (ex) {
-      let reason;
+          case "InvalidPDFException":
+            reason = new _util.InvalidPDFException(ex.message);
+            break;
 
-      switch (ex.name) {
-        case "PasswordException":
-          reason = new _util.PasswordException(ex.message, ex.code);
-          break;
+          case "MissingPDFException":
+            reason = new _util.MissingPDFException(ex.message);
+            break;
 
-        case "InvalidPDFException":
-          reason = new _util.InvalidPDFException(ex.message);
-          break;
+          case "UnexpectedResponseException":
+            reason = new _util.UnexpectedResponseException(ex.message, ex.status);
+            break;
 
-        case "MissingPDFException":
-          reason = new _util.MissingPDFException(ex.message);
-          break;
+          case "UnknownErrorException":
+            reason = new _util.UnknownErrorException(ex.message, ex.details);
+            break;
+        }
 
-        case "UnexpectedResponseException":
-          reason = new _util.UnexpectedResponseException(ex.message, ex.status);
-          break;
+        loadingTask._capability.reject(reason);
+      });
+      messageHandler.on("PasswordRequest", function (exception) {
+        _this14._passwordCapability = (0, _util.createPromiseCapability)();
 
-        case "UnknownErrorException":
-          reason = new _util.UnknownErrorException(ex.message, ex.details);
-          break;
-      }
+        if (loadingTask.onPassword) {
+          var updatePassword = function updatePassword(password) {
+            _this14._passwordCapability.resolve({
+              password: password
+            });
+          };
 
-      loadingTask._capability.reject(reason);
-    });
-    messageHandler.on("PasswordRequest", exception => {
-      this._passwordCapability = (0, _util.createPromiseCapability)();
+          try {
+            loadingTask.onPassword(updatePassword, exception.code);
+          } catch (ex) {
+            _this14._passwordCapability.reject(ex);
+          }
+        } else {
+          _this14._passwordCapability.reject(new _util.PasswordException(exception.message, exception.code));
+        }
 
-      if (loadingTask.onPassword) {
-        const updatePassword = password => {
-          this._passwordCapability.resolve({
-            password
+        return _this14._passwordCapability.promise;
+      });
+      messageHandler.on("DataLoaded", function (data) {
+        if (loadingTask.onProgress) {
+          loadingTask.onProgress({
+            loaded: data.length,
+            total: data.length
           });
-        };
-
-        try {
-          loadingTask.onPassword(updatePassword, exception.code);
-        } catch (ex) {
-          this._passwordCapability.reject(ex);
         }
-      } else {
-        this._passwordCapability.reject(new _util.PasswordException(exception.message, exception.code));
-      }
 
-      return this._passwordCapability.promise;
-    });
-    messageHandler.on("DataLoaded", data => {
-      if (loadingTask.onProgress) {
-        loadingTask.onProgress({
-          loaded: data.length,
-          total: data.length
-        });
-      }
+        _this14.downloadInfoCapability.resolve(data);
+      });
+      messageHandler.on("StartRenderPage", function (data) {
+        if (_this14.destroyed) {
+          return;
+        }
 
-      this.downloadInfoCapability.resolve(data);
-    });
-    messageHandler.on("StartRenderPage", data => {
-      if (this.destroyed) {
-        return;
-      }
+        var page = _this14.pageCache[data.pageIndex];
 
-      const page = this.pageCache[data.pageIndex];
+        page._startRenderPage(data.transparency, data.intent);
+      });
+      messageHandler.on("commonobj", function (data) {
+        if (_this14.destroyed) {
+          return;
+        }
 
-      page._startRenderPage(data.transparency, data.intent);
-    });
-    messageHandler.on("commonobj", data => {
-      if (this.destroyed) {
-        return;
-      }
+        var _data = _slicedToArray(data, 3),
+            id = _data[0],
+            type = _data[1],
+            exportedData = _data[2];
 
-      const [id, type, exportedData] = data;
+        if (_this14.commonObjs.has(id)) {
+          return;
+        }
 
-      if (this.commonObjs.has(id)) {
-        return;
-      }
+        switch (type) {
+          case "Font":
+            var params = _this14._params;
 
-      switch (type) {
-        case "Font":
-          const params = this._params;
+            if ("error" in exportedData) {
+              var exportedError = exportedData.error;
+              (0, _util.warn)("Error during font loading: ".concat(exportedError));
 
-          if ("error" in exportedData) {
-            const exportedError = exportedData.error;
-            (0, _util.warn)(`Error during font loading: ${exportedError}`);
-            this.commonObjs.resolve(id, exportedError);
-            break;
-          }
+              _this14.commonObjs.resolve(id, exportedError);
 
-          let fontRegistry = null;
+              break;
+            }
 
-          if (params.pdfBug && globalThis.FontInspector && globalThis.FontInspector.enabled) {
-            fontRegistry = {
-              registerFont(font, url) {
-                globalThis.FontInspector.fontAdded(font, url);
-              }
+            var fontRegistry = null;
 
-            };
-          }
+            if (params.pdfBug && globalThis.FontInspector && globalThis.FontInspector.enabled) {
+              fontRegistry = {
+                registerFont: function registerFont(font, url) {
+                  globalThis.FontInspector.fontAdded(font, url);
+                }
+              };
+            }
 
-          const font = new _font_loader.FontFaceObject(exportedData, {
-            isEvalSupported: params.isEvalSupported,
-            disableFontFace: params.disableFontFace,
-            ignoreErrors: params.ignoreErrors,
-            onUnsupportedFeature: this._onUnsupportedFeature.bind(this),
-            fontRegistry
-          });
-          this.fontLoader.bind(font).catch(reason => {
-            return messageHandler.sendWithPromise("FontFallback", {
-              id
+            var font = new _font_loader.FontFaceObject(exportedData, {
+              isEvalSupported: params.isEvalSupported,
+              disableFontFace: params.disableFontFace,
+              ignoreErrors: params.ignoreErrors,
+              onUnsupportedFeature: _this14._onUnsupportedFeature.bind(_this14),
+              fontRegistry: fontRegistry
             });
-          }).finally(() => {
-            if (!params.fontExtraProperties && font.data) {
-              font.data = null;
-            }
 
-            this.commonObjs.resolve(id, font);
-          });
-          break;
+            _this14.fontLoader.bind(font)["catch"](function (reason) {
+              return messageHandler.sendWithPromise("FontFallback", {
+                id: id
+              });
+            })["finally"](function () {
+              if (!params.fontExtraProperties && font.data) {
+                font.data = null;
+              }
 
-        case "FontPath":
-        case "FontType3Res":
-        case "Image":
-          this.commonObjs.resolve(id, exportedData);
-          break;
+              _this14.commonObjs.resolve(id, font);
+            });
 
-        default:
-          throw new Error(`Got unknown common object type ${type}`);
-      }
-    });
-    messageHandler.on("obj", data => {
-      if (this.destroyed) {
-        return undefined;
-      }
+            break;
 
-      const [id, pageIndex, type, imageData] = data;
-      const pageProxy = this.pageCache[pageIndex];
+          case "FontPath":
+          case "FontType3Res":
+          case "Image":
+            _this14.commonObjs.resolve(id, exportedData);
 
-      if (pageProxy.objs.has(id)) {
-        return undefined;
-      }
+            break;
 
-      switch (type) {
-        case "Image":
-          pageProxy.objs.resolve(id, imageData);
-          const MAX_IMAGE_SIZE_TO_STORE = 8000000;
+          default:
+            throw new Error("Got unknown common object type ".concat(type));
+        }
+      });
+      messageHandler.on("obj", function (data) {
+        if (_this14.destroyed) {
+          return undefined;
+        }
 
-          if (imageData && "data" in imageData && imageData.data.length > MAX_IMAGE_SIZE_TO_STORE) {
-            pageProxy.cleanupAfterRender = true;
-          }
+        var _data2 = _slicedToArray(data, 4),
+            id = _data2[0],
+            pageIndex = _data2[1],
+            type = _data2[2],
+            imageData = _data2[3];
 
-          break;
+        var pageProxy = _this14.pageCache[pageIndex];
 
-        default:
-          throw new Error(`Got unknown object type ${type}`);
-      }
+        if (pageProxy.objs.has(id)) {
+          return undefined;
+        }
 
-      return undefined;
-    });
-    messageHandler.on("DocProgress", data => {
-      if (this.destroyed) {
-        return;
-      }
+        switch (type) {
+          case "Image":
+            pageProxy.objs.resolve(id, imageData);
+            var MAX_IMAGE_SIZE_TO_STORE = 8000000;
 
-      if (loadingTask.onProgress) {
-        loadingTask.onProgress({
-          loaded: data.loaded,
-          total: data.total
-        });
-      }
-    });
-    messageHandler.on("UnsupportedFeature", this._onUnsupportedFeature.bind(this));
-    messageHandler.on("FetchBuiltInCMap", (data, sink) => {
-      if (this.destroyed) {
-        sink.error(new Error("Worker was destroyed"));
-        return;
-      }
+            if (imageData && "data" in imageData && imageData.data.length > MAX_IMAGE_SIZE_TO_STORE) {
+              pageProxy.cleanupAfterRender = true;
+            }
 
-      let fetched = false;
+            break;
 
-      sink.onPull = () => {
-        if (fetched) {
-          sink.close();
+          default:
+            throw new Error("Got unknown object type ".concat(type));
+        }
+
+        return undefined;
+      });
+      messageHandler.on("DocProgress", function (data) {
+        if (_this14.destroyed) {
           return;
         }
 
-        fetched = true;
-        this.CMapReaderFactory.fetch(data).then(function (builtInCMap) {
-          sink.enqueue(builtInCMap, 1, [builtInCMap.cMapData.buffer]);
-        }).catch(function (reason) {
-          sink.error(reason);
-        });
-      };
-    });
-  }
+        if (loadingTask.onProgress) {
+          loadingTask.onProgress({
+            loaded: data.loaded,
+            total: data.total
+          });
+        }
+      });
+      messageHandler.on("UnsupportedFeature", this._onUnsupportedFeature.bind(this));
+      messageHandler.on("FetchBuiltInCMap", function (data, sink) {
+        if (_this14.destroyed) {
+          sink.error(new Error("Worker was destroyed"));
+          return;
+        }
 
-  _onUnsupportedFeature({
-    featureId
-  }) {
-    if (this.destroyed) {
-      return;
-    }
+        var fetched = false;
 
-    if (this.loadingTask.onUnsupportedFeature) {
-      this.loadingTask.onUnsupportedFeature(featureId);
-    }
-  }
+        sink.onPull = function () {
+          if (fetched) {
+            sink.close();
+            return;
+          }
 
-  getData() {
-    return this.messageHandler.sendWithPromise("GetData", null);
-  }
+          fetched = true;
 
-  getPage(pageNumber) {
-    if (!Number.isInteger(pageNumber) || pageNumber <= 0 || pageNumber > this._numPages) {
-      return Promise.reject(new Error("Invalid page request"));
+          _this14.CMapReaderFactory.fetch(data).then(function (builtInCMap) {
+            sink.enqueue(builtInCMap, 1, [builtInCMap.cMapData.buffer]);
+          })["catch"](function (reason) {
+            sink.error(reason);
+          });
+        };
+      });
     }
+  }, {
+    key: "_onUnsupportedFeature",
+    value: function _onUnsupportedFeature(_ref15) {
+      var featureId = _ref15.featureId;
 
-    const pageIndex = pageNumber - 1;
+      if (this.destroyed) {
+        return;
+      }
 
-    if (pageIndex in this.pagePromises) {
-      return this.pagePromises[pageIndex];
+      if (this.loadingTask.onUnsupportedFeature) {
+        this.loadingTask.onUnsupportedFeature(featureId);
+      }
+    }
+  }, {
+    key: "getData",
+    value: function getData() {
+      return this.messageHandler.sendWithPromise("GetData", null);
     }
+  }, {
+    key: "getPage",
+    value: function getPage(pageNumber) {
+      var _this15 = this;
 
-    const promise = this.messageHandler.sendWithPromise("GetPage", {
-      pageIndex
-    }).then(pageInfo => {
-      if (this.destroyed) {
-        throw new Error("Transport destroyed");
+      if (!Number.isInteger(pageNumber) || pageNumber <= 0 || pageNumber > this._numPages) {
+        return Promise.reject(new Error("Invalid page request"));
       }
 
-      const page = new PDFPageProxy(pageIndex, pageInfo, this, this._params.pdfBug);
-      this.pageCache[pageIndex] = page;
-      return page;
-    });
-    this.pagePromises[pageIndex] = promise;
-    return promise;
-  }
-
-  getPageIndex(ref) {
-    return this.messageHandler.sendWithPromise("GetPageIndex", {
-      ref
-    }).catch(function (reason) {
-      return Promise.reject(new Error(reason));
-    });
-  }
+      var pageIndex = pageNumber - 1;
 
-  getAnnotations(pageIndex, intent) {
-    return this.messageHandler.sendWithPromise("GetAnnotations", {
-      pageIndex,
-      intent
-    });
-  }
+      if (pageIndex in this.pagePromises) {
+        return this.pagePromises[pageIndex];
+      }
 
-  getDestinations() {
-    return this.messageHandler.sendWithPromise("GetDestinations", null);
-  }
+      var promise = this.messageHandler.sendWithPromise("GetPage", {
+        pageIndex: pageIndex
+      }).then(function (pageInfo) {
+        if (_this15.destroyed) {
+          throw new Error("Transport destroyed");
+        }
 
-  getDestination(id) {
-    if (typeof id !== "string") {
-      return Promise.reject(new Error("Invalid destination request."));
+        var page = new PDFPageProxy(pageIndex, pageInfo, _this15, _this15._params.pdfBug);
+        _this15.pageCache[pageIndex] = page;
+        return page;
+      });
+      this.pagePromises[pageIndex] = promise;
+      return promise;
+    }
+  }, {
+    key: "getPageIndex",
+    value: function getPageIndex(ref) {
+      return this.messageHandler.sendWithPromise("GetPageIndex", {
+        ref: ref
+      })["catch"](function (reason) {
+        return Promise.reject(new Error(reason));
+      });
+    }
+  }, {
+    key: "getAnnotations",
+    value: function getAnnotations(pageIndex, intent) {
+      return this.messageHandler.sendWithPromise("GetAnnotations", {
+        pageIndex: pageIndex,
+        intent: intent
+      });
+    }
+  }, {
+    key: "getDestinations",
+    value: function getDestinations() {
+      return this.messageHandler.sendWithPromise("GetDestinations", null);
     }
+  }, {
+    key: "getDestination",
+    value: function getDestination(id) {
+      if (typeof id !== "string") {
+        return Promise.reject(new Error("Invalid destination request."));
+      }
 
-    return this.messageHandler.sendWithPromise("GetDestination", {
-      id
-    });
-  }
+      return this.messageHandler.sendWithPromise("GetDestination", {
+        id: id
+      });
+    }
+  }, {
+    key: "getPageLabels",
+    value: function getPageLabels() {
+      return this.messageHandler.sendWithPromise("GetPageLabels", null);
+    }
+  }, {
+    key: "getPageLayout",
+    value: function getPageLayout() {
+      return this.messageHandler.sendWithPromise("GetPageLayout", null);
+    }
+  }, {
+    key: "getPageMode",
+    value: function getPageMode() {
+      return this.messageHandler.sendWithPromise("GetPageMode", null);
+    }
+  }, {
+    key: "getViewerPreferences",
+    value: function getViewerPreferences() {
+      return this.messageHandler.sendWithPromise("GetViewerPreferences", null);
+    }
+  }, {
+    key: "getOpenAction",
+    value: function getOpenAction() {
+      return this.messageHandler.sendWithPromise("GetOpenAction", null);
+    }
+  }, {
+    key: "getAttachments",
+    value: function getAttachments() {
+      return this.messageHandler.sendWithPromise("GetAttachments", null);
+    }
+  }, {
+    key: "getJavaScript",
+    value: function getJavaScript() {
+      return this.messageHandler.sendWithPromise("GetJavaScript", null);
+    }
+  }, {
+    key: "getOutline",
+    value: function getOutline() {
+      return this.messageHandler.sendWithPromise("GetOutline", null);
+    }
+  }, {
+    key: "getPermissions",
+    value: function getPermissions() {
+      return this.messageHandler.sendWithPromise("GetPermissions", null);
+    }
+  }, {
+    key: "getMetadata",
+    value: function getMetadata() {
+      var _this16 = this;
+
+      return this.messageHandler.sendWithPromise("GetMetadata", null).then(function (results) {
+        return {
+          info: results[0],
+          metadata: results[1] ? new _metadata.Metadata(results[1]) : null,
+          contentDispositionFilename: _this16._fullReader ? _this16._fullReader.filename : null
+        };
+      });
+    }
+  }, {
+    key: "getStats",
+    value: function getStats() {
+      return this.messageHandler.sendWithPromise("GetStats", null);
+    }
+  }, {
+    key: "startCleanup",
+    value: function startCleanup() {
+      var _this17 = this;
 
-  getPageLabels() {
-    return this.messageHandler.sendWithPromise("GetPageLabels", null);
-  }
+      return this.messageHandler.sendWithPromise("Cleanup", null).then(function () {
+        for (var i = 0, ii = _this17.pageCache.length; i < ii; i++) {
+          var page = _this17.pageCache[i];
 
-  getPageLayout() {
-    return this.messageHandler.sendWithPromise("GetPageLayout", null);
-  }
+          if (page) {
+            var cleanupSuccessful = page.cleanup();
 
-  getPageMode() {
-    return this.messageHandler.sendWithPromise("GetPageMode", null);
-  }
+            if (!cleanupSuccessful) {
+              throw new Error("startCleanup: Page ".concat(i + 1, " is currently rendering."));
+            }
+          }
+        }
 
-  getViewerPreferences() {
-    return this.messageHandler.sendWithPromise("GetViewerPreferences", null);
-  }
+        _this17.commonObjs.clear();
 
-  getOpenAction() {
-    return this.messageHandler.sendWithPromise("GetOpenAction", null);
-  }
+        _this17.fontLoader.clear();
+      });
+    }
+  }, {
+    key: "loadingParams",
+    get: function get() {
+      var params = this._params;
+      return (0, _util.shadow)(this, "loadingParams", {
+        disableAutoFetch: params.disableAutoFetch,
+        disableFontFace: params.disableFontFace
+      });
+    }
+  }]);
 
-  getAttachments() {
-    return this.messageHandler.sendWithPromise("GetAttachments", null);
-  }
+  return WorkerTransport;
+}();
 
-  getJavaScript() {
-    return this.messageHandler.sendWithPromise("GetJavaScript", null);
-  }
+var PDFObjects = /*#__PURE__*/function () {
+  function PDFObjects() {
+    _classCallCheck(this, PDFObjects);
 
-  getOutline() {
-    return this.messageHandler.sendWithPromise("GetOutline", null);
+    this._objs = Object.create(null);
   }
 
-  getPermissions() {
-    return this.messageHandler.sendWithPromise("GetPermissions", null);
-  }
+  _createClass(PDFObjects, [{
+    key: "_ensureObj",
+    value: function _ensureObj(objId) {
+      if (this._objs[objId]) {
+        return this._objs[objId];
+      }
 
-  getMetadata() {
-    return this.messageHandler.sendWithPromise("GetMetadata", null).then(results => {
-      return {
-        info: results[0],
-        metadata: results[1] ? new _metadata.Metadata(results[1]) : null,
-        contentDispositionFilename: this._fullReader ? this._fullReader.filename : null
+      return this._objs[objId] = {
+        capability: (0, _util.createPromiseCapability)(),
+        data: null,
+        resolved: false
       };
-    });
-  }
-
-  getStats() {
-    return this.messageHandler.sendWithPromise("GetStats", null);
-  }
+    }
+  }, {
+    key: "get",
+    value: function get(objId) {
+      var callback = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : null;
 
-  startCleanup() {
-    return this.messageHandler.sendWithPromise("Cleanup", null).then(() => {
-      for (let i = 0, ii = this.pageCache.length; i < ii; i++) {
-        const page = this.pageCache[i];
+      if (callback) {
+        this._ensureObj(objId).capability.promise.then(callback);
 
-        if (page) {
-          const cleanupSuccessful = page.cleanup();
-
-          if (!cleanupSuccessful) {
-            throw new Error(`startCleanup: Page ${i + 1} is currently rendering.`);
-          }
-        }
+        return null;
       }
 
-      this.commonObjs.clear();
-      this.fontLoader.clear();
-    });
-  }
-
-  get loadingParams() {
-    const params = this._params;
-    return (0, _util.shadow)(this, "loadingParams", {
-      disableAutoFetch: params.disableAutoFetch,
-      disableFontFace: params.disableFontFace
-    });
-  }
+      var obj = this._objs[objId];
 
-}
-
-class PDFObjects {
-  constructor() {
-    this._objs = Object.create(null);
-  }
+      if (!obj || !obj.resolved) {
+        throw new Error("Requesting object that isn't resolved yet ".concat(objId, "."));
+      }
 
-  _ensureObj(objId) {
-    if (this._objs[objId]) {
-      return this._objs[objId];
+      return obj.data;
     }
-
-    return this._objs[objId] = {
-      capability: (0, _util.createPromiseCapability)(),
-      data: null,
-      resolved: false
-    };
-  }
-
-  get(objId, callback = null) {
-    if (callback) {
-      this._ensureObj(objId).capability.promise.then(callback);
-
-      return null;
+  }, {
+    key: "has",
+    value: function has(objId) {
+      var obj = this._objs[objId];
+      return obj ? obj.resolved : false;
     }
+  }, {
+    key: "resolve",
+    value: function resolve(objId, data) {
+      var obj = this._ensureObj(objId);
 
-    const obj = this._objs[objId];
-
-    if (!obj || !obj.resolved) {
-      throw new Error(`Requesting object that isn't resolved yet ${objId}.`);
+      obj.resolved = true;
+      obj.data = data;
+      obj.capability.resolve(data);
     }
+  }, {
+    key: "clear",
+    value: function clear() {
+      this._objs = Object.create(null);
+    }
+  }]);
 
-    return obj.data;
-  }
-
-  has(objId) {
-    const obj = this._objs[objId];
-    return obj ? obj.resolved : false;
-  }
-
-  resolve(objId, data) {
-    const obj = this._ensureObj(objId);
-
-    obj.resolved = true;
-    obj.data = data;
-    obj.capability.resolve(data);
-  }
-
-  clear() {
-    this._objs = Object.create(null);
-  }
+  return PDFObjects;
+}();
 
-}
+var RenderTask = /*#__PURE__*/function () {
+  function RenderTask(internalRenderTask) {
+    _classCallCheck(this, RenderTask);
 
-class RenderTask {
-  constructor(internalRenderTask) {
     this._internalRenderTask = internalRenderTask;
     this.onContinue = null;
   }
 
-  get promise() {
-    return this._internalRenderTask.capability.promise;
-  }
+  _createClass(RenderTask, [{
+    key: "cancel",
+    value: function cancel() {
+      this._internalRenderTask.cancel();
+    }
+  }, {
+    key: "promise",
+    get: function get() {
+      return this._internalRenderTask.capability.promise;
+    }
+  }]);
 
-  cancel() {
-    this._internalRenderTask.cancel();
-  }
+  return RenderTask;
+}();
 
-}
+var InternalRenderTask = function InternalRenderTaskClosure() {
+  var canvasInRendering = new WeakSet();
+
+  var InternalRenderTask = /*#__PURE__*/function () {
+    function InternalRenderTask(_ref16) {
+      var callback = _ref16.callback,
+          params = _ref16.params,
+          objs = _ref16.objs,
+          commonObjs = _ref16.commonObjs,
+          operatorList = _ref16.operatorList,
+          pageIndex = _ref16.pageIndex,
+          canvasFactory = _ref16.canvasFactory,
+          webGLContext = _ref16.webGLContext,
+          _ref16$useRequestAnim = _ref16.useRequestAnimationFrame,
+          useRequestAnimationFrame = _ref16$useRequestAnim === void 0 ? false : _ref16$useRequestAnim,
+          _ref16$pdfBug = _ref16.pdfBug,
+          pdfBug = _ref16$pdfBug === void 0 ? false : _ref16$pdfBug;
+
+      _classCallCheck(this, InternalRenderTask);
 
-const InternalRenderTask = function InternalRenderTaskClosure() {
-  const canvasInRendering = new WeakSet();
-
-  class InternalRenderTask {
-    constructor({
-      callback,
-      params,
-      objs,
-      commonObjs,
-      operatorList,
-      pageIndex,
-      canvasFactory,
-      webGLContext,
-      useRequestAnimationFrame = false,
-      pdfBug = false
-    }) {
       this.callback = callback;
       this.params = params;
       this.objs = objs;
@@ -3671,140 +14349,176 @@ const InternalRenderTask = function InternalRenderTaskClosure() {
       this._canvas = params.canvasContext.canvas;
     }
 
-    initializeGraphics(transparency = false) {
-      if (this.cancelled) {
-        return;
-      }
+    _createClass(InternalRenderTask, [{
+      key: "initializeGraphics",
+      value: function initializeGraphics() {
+        var transparency = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : false;
 
-      if (this._canvas) {
-        if (canvasInRendering.has(this._canvas)) {
-          throw new Error("Cannot use the same canvas during multiple render() operations. " + "Use different canvas or ensure previous operations were " + "cancelled or completed.");
+        if (this.cancelled) {
+          return;
         }
 
-        canvasInRendering.add(this._canvas);
-      }
-
-      if (this._pdfBug && globalThis.StepperManager && globalThis.StepperManager.enabled) {
-        this.stepper = globalThis.StepperManager.create(this._pageIndex);
-        this.stepper.init(this.operatorList);
-        this.stepper.nextBreakPoint = this.stepper.getNextBreakPoint();
-      }
-
-      const {
-        canvasContext,
-        viewport,
-        transform,
-        imageLayer,
-        background
-      } = this.params;
-      this.gfx = new _canvas.CanvasGraphics(canvasContext, this.commonObjs, this.objs, this.canvasFactory, this.webGLContext, imageLayer);
-      this.gfx.beginDrawing({
-        transform,
-        viewport,
-        transparency,
-        background
-      });
-      this.operatorListIdx = 0;
-      this.graphicsReady = true;
+        if (this._canvas) {
+          if (canvasInRendering.has(this._canvas)) {
+            throw new Error("Cannot use the same canvas during multiple render() operations. " + "Use different canvas or ensure previous operations were " + "cancelled or completed.");
+          }
 
-      if (this.graphicsReadyCallback) {
-        this.graphicsReadyCallback();
-      }
-    }
+          canvasInRendering.add(this._canvas);
+        }
 
-    cancel(error = null) {
-      this.running = false;
-      this.cancelled = true;
+        if (this._pdfBug && globalThis.StepperManager && globalThis.StepperManager.enabled) {
+          this.stepper = globalThis.StepperManager.create(this._pageIndex);
+          this.stepper.init(this.operatorList);
+          this.stepper.nextBreakPoint = this.stepper.getNextBreakPoint();
+        }
 
-      if (this.gfx) {
-        this.gfx.endDrawing();
-      }
+        var _this$params = this.params,
+            canvasContext = _this$params.canvasContext,
+            viewport = _this$params.viewport,
+            transform = _this$params.transform,
+            imageLayer = _this$params.imageLayer,
+            background = _this$params.background;
+        this.gfx = new _canvas.CanvasGraphics(canvasContext, this.commonObjs, this.objs, this.canvasFactory, this.webGLContext, imageLayer);
+        this.gfx.beginDrawing({
+          transform: transform,
+          viewport: viewport,
+          transparency: transparency,
+          background: background
+        });
+        this.operatorListIdx = 0;
+        this.graphicsReady = true;
 
-      if (this._canvas) {
-        canvasInRendering.delete(this._canvas);
+        if (this.graphicsReadyCallback) {
+          this.graphicsReadyCallback();
+        }
       }
+    }, {
+      key: "cancel",
+      value: function cancel() {
+        var error = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : null;
+        this.running = false;
+        this.cancelled = true;
 
-      this.callback(error || new _display_utils.RenderingCancelledException(`Rendering cancelled, page ${this._pageIndex + 1}`, "canvas"));
-    }
-
-    operatorListChanged() {
-      if (!this.graphicsReady) {
-        if (!this.graphicsReadyCallback) {
-          this.graphicsReadyCallback = this._continueBound;
+        if (this.gfx) {
+          this.gfx.endDrawing();
         }
 
-        return;
-      }
+        if (this._canvas) {
+          canvasInRendering["delete"](this._canvas);
+        }
 
-      if (this.stepper) {
-        this.stepper.updateOperatorList(this.operatorList);
+        this.callback(error || new _display_utils.RenderingCancelledException("Rendering cancelled, page ".concat(this._pageIndex + 1), "canvas"));
       }
+    }, {
+      key: "operatorListChanged",
+      value: function operatorListChanged() {
+        if (!this.graphicsReady) {
+          if (!this.graphicsReadyCallback) {
+            this.graphicsReadyCallback = this._continueBound;
+          }
 
-      if (this.running) {
-        return;
-      }
+          return;
+        }
 
-      this._continue();
-    }
+        if (this.stepper) {
+          this.stepper.updateOperatorList(this.operatorList);
+        }
 
-    _continue() {
-      this.running = true;
+        if (this.running) {
+          return;
+        }
 
-      if (this.cancelled) {
-        return;
+        this._continue();
       }
+    }, {
+      key: "_continue",
+      value: function _continue() {
+        this.running = true;
 
-      if (this.task.onContinue) {
-        this.task.onContinue(this._scheduleNextBound);
-      } else {
-        this._scheduleNext();
-      }
-    }
+        if (this.cancelled) {
+          return;
+        }
 
-    _scheduleNext() {
-      if (this._useRequestAnimationFrame) {
-        window.requestAnimationFrame(() => {
-          this._nextBound().catch(this.cancel.bind(this));
-        });
-      } else {
-        Promise.resolve().then(this._nextBound).catch(this.cancel.bind(this));
+        if (this.task.onContinue) {
+          this.task.onContinue(this._scheduleNextBound);
+        } else {
+          this._scheduleNext();
+        }
       }
-    }
+    }, {
+      key: "_scheduleNext",
+      value: function _scheduleNext() {
+        var _this18 = this;
 
-    async _next() {
-      if (this.cancelled) {
-        return;
+        if (this._useRequestAnimationFrame) {
+          window.requestAnimationFrame(function () {
+            _this18._nextBound()["catch"](_this18.cancel.bind(_this18));
+          });
+        } else {
+          Promise.resolve().then(this._nextBound)["catch"](this.cancel.bind(this));
+        }
       }
+    }, {
+      key: "_next",
+      value: function () {
+        var _next2 = _asyncToGenerator( /*#__PURE__*/_regenerator["default"].mark(function _callee2() {
+          return _regenerator["default"].wrap(function _callee2$(_context2) {
+            while (1) {
+              switch (_context2.prev = _context2.next) {
+                case 0:
+                  if (!this.cancelled) {
+                    _context2.next = 2;
+                    break;
+                  }
+
+                  return _context2.abrupt("return");
+
+                case 2:
+                  this.operatorListIdx = this.gfx.executeOperatorList(this.operatorList, this.operatorListIdx, this._continueBound, this.stepper);
+
+                  if (this.operatorListIdx === this.operatorList.argsArray.length) {
+                    this.running = false;
+
+                    if (this.operatorList.lastChunk) {
+                      this.gfx.endDrawing();
+
+                      if (this._canvas) {
+                        canvasInRendering["delete"](this._canvas);
+                      }
+
+                      this.callback();
+                    }
+                  }
+
+                case 4:
+                case "end":
+                  return _context2.stop();
+              }
+            }
+          }, _callee2, this);
+        }));
 
-      this.operatorListIdx = this.gfx.executeOperatorList(this.operatorList, this.operatorListIdx, this._continueBound, this.stepper);
-
-      if (this.operatorListIdx === this.operatorList.argsArray.length) {
-        this.running = false;
-
-        if (this.operatorList.lastChunk) {
-          this.gfx.endDrawing();
-
-          if (this._canvas) {
-            canvasInRendering.delete(this._canvas);
-          }
-
-          this.callback();
+        function _next() {
+          return _next2.apply(this, arguments);
         }
-      }
-    }
 
-  }
+        return _next;
+      }()
+    }]);
+
+    return InternalRenderTask;
+  }();
 
   return InternalRenderTask;
 }();
 
-const version = '2.5.207';
+var version = '2.5.207';
 exports.version = version;
-const build = '0974d6052';
+var build = '0974d6052';
 exports.build = build;
 
 /***/ }),
-/* 6 */
+/* 199 */
 /***/ (function(module, exports, __w_pdfjs_require__) {
 
 "use strict";
@@ -3815,13 +14529,45 @@ Object.defineProperty(exports, "__esModule", {
 });
 exports.FontLoader = exports.FontFaceObject = void 0;
 
-var _util = __w_pdfjs_require__(2);
+var _regenerator = _interopRequireDefault(__w_pdfjs_require__(2));
+
+var _util = __w_pdfjs_require__(5);
+
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { "default": obj }; }
+
+function _typeof(obj) { "@babel/helpers - typeof"; 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 _inherits(subClass, superClass) { if (typeof superClass !== "function" && superClass !== null) { throw new TypeError("Super expression must either be null or a function"); } subClass.prototype = Object.create(superClass && superClass.prototype, { constructor: { value: subClass, writable: true, configurable: true } }); if (superClass) _setPrototypeOf(subClass, superClass); }
+
+function _setPrototypeOf(o, p) { _setPrototypeOf = Object.setPrototypeOf || function _setPrototypeOf(o, p) { o.__proto__ = p; return o; }; return _setPrototypeOf(o, p); }
+
+function _createSuper(Derived) { var hasNativeReflectConstruct = _isNativeReflectConstruct(); return function _createSuperInternal() { var Super = _getPrototypeOf(Derived), result; if (hasNativeReflectConstruct) { var NewTarget = _getPrototypeOf(this).constructor; result = Reflect.construct(Super, arguments, NewTarget); } else { result = Super.apply(this, arguments); } return _possibleConstructorReturn(this, result); }; }
+
+function _possibleConstructorReturn(self, call) { if (call && (_typeof(call) === "object" || typeof call === "function")) { return call; } return _assertThisInitialized(self); }
+
+function _assertThisInitialized(self) { if (self === void 0) { throw new ReferenceError("this hasn't been initialised - super() hasn't been called"); } return self; }
+
+function _isNativeReflectConstruct() { if (typeof Reflect === "undefined" || !Reflect.construct) return false; if (Reflect.construct.sham) return false; if (typeof Proxy === "function") return true; try { Date.prototype.toString.call(Reflect.construct(Date, [], function () {})); return true; } catch (e) { return false; } }
+
+function _getPrototypeOf(o) { _getPrototypeOf = Object.setPrototypeOf ? Object.getPrototypeOf : function _getPrototypeOf(o) { return o.__proto__ || Object.getPrototypeOf(o); }; return _getPrototypeOf(o); }
+
+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 BaseFontLoader = /*#__PURE__*/function () {
+  function BaseFontLoader(_ref) {
+    var docId = _ref.docId,
+        onUnsupportedFeature = _ref.onUnsupportedFeature;
+
+    _classCallCheck(this, BaseFontLoader);
 
-class BaseFontLoader {
-  constructor({
-    docId,
-    onUnsupportedFeature
-  }) {
     if (this.constructor === BaseFontLoader) {
       (0, _util.unreachable)("Cannot initialize BaseFontLoader.");
     }
@@ -3832,264 +14578,348 @@ class BaseFontLoader {
     this.styleElement = null;
   }
 
-  addNativeFontFace(nativeFontFace) {
-    this.nativeFontFaces.push(nativeFontFace);
-    document.fonts.add(nativeFontFace);
-  }
+  _createClass(BaseFontLoader, [{
+    key: "addNativeFontFace",
+    value: function addNativeFontFace(nativeFontFace) {
+      this.nativeFontFaces.push(nativeFontFace);
+      document.fonts.add(nativeFontFace);
+    }
+  }, {
+    key: "insertRule",
+    value: function insertRule(rule) {
+      var styleElement = this.styleElement;
 
-  insertRule(rule) {
-    let styleElement = this.styleElement;
+      if (!styleElement) {
+        styleElement = this.styleElement = document.createElement("style");
+        styleElement.id = "PDFJS_FONT_STYLE_TAG_".concat(this.docId);
+        document.documentElement.getElementsByTagName("head")[0].appendChild(styleElement);
+      }
 
-    if (!styleElement) {
-      styleElement = this.styleElement = document.createElement("style");
-      styleElement.id = `PDFJS_FONT_STYLE_TAG_${this.docId}`;
-      document.documentElement.getElementsByTagName("head")[0].appendChild(styleElement);
+      var styleSheet = styleElement.sheet;
+      styleSheet.insertRule(rule, styleSheet.cssRules.length);
     }
+  }, {
+    key: "clear",
+    value: function clear() {
+      this.nativeFontFaces.forEach(function (nativeFontFace) {
+        document.fonts["delete"](nativeFontFace);
+      });
+      this.nativeFontFaces.length = 0;
+
+      if (this.styleElement) {
+        this.styleElement.remove();
+        this.styleElement = null;
+      }
+    }
+  }, {
+    key: "bind",
+    value: function () {
+      var _bind = _asyncToGenerator( /*#__PURE__*/_regenerator["default"].mark(function _callee(font) {
+        var _this = this;
+
+        var nativeFontFace, rule;
+        return _regenerator["default"].wrap(function _callee$(_context) {
+          while (1) {
+            switch (_context.prev = _context.next) {
+              case 0:
+                if (!(font.attached || font.missingFile)) {
+                  _context.next = 2;
+                  break;
+                }
 
-    const styleSheet = styleElement.sheet;
-    styleSheet.insertRule(rule, styleSheet.cssRules.length);
-  }
+                return _context.abrupt("return");
 
-  clear() {
-    this.nativeFontFaces.forEach(function (nativeFontFace) {
-      document.fonts.delete(nativeFontFace);
-    });
-    this.nativeFontFaces.length = 0;
+              case 2:
+                font.attached = true;
 
-    if (this.styleElement) {
-      this.styleElement.remove();
-      this.styleElement = null;
-    }
-  }
+                if (!this.isFontLoadingAPISupported) {
+                  _context.next = 19;
+                  break;
+                }
 
-  async bind(font) {
-    if (font.attached || font.missingFile) {
-      return;
-    }
+                nativeFontFace = font.createNativeFontFace();
 
-    font.attached = true;
+                if (!nativeFontFace) {
+                  _context.next = 18;
+                  break;
+                }
 
-    if (this.isFontLoadingAPISupported) {
-      const nativeFontFace = font.createNativeFontFace();
+                this.addNativeFontFace(nativeFontFace);
+                _context.prev = 7;
+                _context.next = 10;
+                return nativeFontFace.loaded;
 
-      if (nativeFontFace) {
-        this.addNativeFontFace(nativeFontFace);
+              case 10:
+                _context.next = 18;
+                break;
 
-        try {
-          await nativeFontFace.loaded;
-        } catch (ex) {
-          this._onUnsupportedFeature({
-            featureId: _util.UNSUPPORTED_FEATURES.errorFontLoadNative
-          });
+              case 12:
+                _context.prev = 12;
+                _context.t0 = _context["catch"](7);
 
-          (0, _util.warn)(`Failed to load font '${nativeFontFace.family}': '${ex}'.`);
-          font.disableFontFace = true;
-          throw ex;
-        }
-      }
+                this._onUnsupportedFeature({
+                  featureId: _util.UNSUPPORTED_FEATURES.errorFontLoadNative
+                });
 
-      return;
-    }
+                (0, _util.warn)("Failed to load font '".concat(nativeFontFace.family, "': '").concat(_context.t0, "'."));
+                font.disableFontFace = true;
+                throw _context.t0;
 
-    const rule = font.createFontFaceRule();
+              case 18:
+                return _context.abrupt("return");
 
-    if (rule) {
-      this.insertRule(rule);
+              case 19:
+                rule = font.createFontFaceRule();
 
-      if (this.isSyncFontLoadingSupported) {
-        return;
-      }
+                if (!rule) {
+                  _context.next = 26;
+                  break;
+                }
 
-      await new Promise(resolve => {
-        const request = this._queueLoadingCallback(resolve);
+                this.insertRule(rule);
 
-        this._prepareFontLoadEvent([rule], [font], request);
-      });
-    }
-  }
+                if (!this.isSyncFontLoadingSupported) {
+                  _context.next = 24;
+                  break;
+                }
 
-  _queueLoadingCallback(callback) {
-    (0, _util.unreachable)("Abstract method `_queueLoadingCallback`.");
-  }
+                return _context.abrupt("return");
 
-  get isFontLoadingAPISupported() {
-    const supported = typeof document !== "undefined" && !!document.fonts;
-    return (0, _util.shadow)(this, "isFontLoadingAPISupported", supported);
-  }
+              case 24:
+                _context.next = 26;
+                return new Promise(function (resolve) {
+                  var request = _this._queueLoadingCallback(resolve);
 
-  get isSyncFontLoadingSupported() {
-    (0, _util.unreachable)("Abstract method `isSyncFontLoadingSupported`.");
-  }
+                  _this._prepareFontLoadEvent([rule], [font], request);
+                });
 
-  get _loadTestFont() {
-    (0, _util.unreachable)("Abstract method `_loadTestFont`.");
-  }
+              case 26:
+              case "end":
+                return _context.stop();
+            }
+          }
+        }, _callee, this, [[7, 12]]);
+      }));
 
-  _prepareFontLoadEvent(rules, fontsToLoad, request) {
-    (0, _util.unreachable)("Abstract method `_prepareFontLoadEvent`.");
-  }
+      function bind(_x) {
+        return _bind.apply(this, arguments);
+      }
 
-}
+      return bind;
+    }()
+  }, {
+    key: "_queueLoadingCallback",
+    value: function _queueLoadingCallback(callback) {
+      (0, _util.unreachable)("Abstract method `_queueLoadingCallback`.");
+    }
+  }, {
+    key: "_prepareFontLoadEvent",
+    value: function _prepareFontLoadEvent(rules, fontsToLoad, request) {
+      (0, _util.unreachable)("Abstract method `_prepareFontLoadEvent`.");
+    }
+  }, {
+    key: "isFontLoadingAPISupported",
+    get: function get() {
+      var supported = typeof document !== "undefined" && !!document.fonts;
+      return (0, _util.shadow)(this, "isFontLoadingAPISupported", supported);
+    }
+  }, {
+    key: "isSyncFontLoadingSupported",
+    get: function get() {
+      (0, _util.unreachable)("Abstract method `isSyncFontLoadingSupported`.");
+    }
+  }, {
+    key: "_loadTestFont",
+    get: function get() {
+      (0, _util.unreachable)("Abstract method `_loadTestFont`.");
+    }
+  }]);
 
-let FontLoader;
+  return BaseFontLoader;
+}();
+
+var FontLoader;
 exports.FontLoader = FontLoader;
 {
-  exports.FontLoader = FontLoader = class GenericFontLoader extends BaseFontLoader {
-    constructor(docId) {
-      super(docId);
-      this.loadingContext = {
+  exports.FontLoader = FontLoader = /*#__PURE__*/function (_BaseFontLoader) {
+    _inherits(GenericFontLoader, _BaseFontLoader);
+
+    var _super = _createSuper(GenericFontLoader);
+
+    function GenericFontLoader(docId) {
+      var _this2;
+
+      _classCallCheck(this, GenericFontLoader);
+
+      _this2 = _super.call(this, docId);
+      _this2.loadingContext = {
         requests: [],
         nextRequestId: 0
       };
-      this.loadTestFontId = 0;
+      _this2.loadTestFontId = 0;
+      return _this2;
     }
 
-    get isSyncFontLoadingSupported() {
-      let supported = false;
-
-      if (typeof navigator === "undefined") {
-        supported = true;
-      } else {
-        const m = /Mozilla\/5.0.*?rv:(\d+).*? Gecko/.exec(navigator.userAgent);
+    _createClass(GenericFontLoader, [{
+      key: "_queueLoadingCallback",
+      value: function _queueLoadingCallback(callback) {
+        function completeRequest() {
+          (0, _util.assert)(!request.done, "completeRequest() cannot be called twice.");
+          request.done = true;
 
-        if (m && m[1] >= 14) {
-          supported = true;
+          while (context.requests.length > 0 && context.requests[0].done) {
+            var otherRequest = context.requests.shift();
+            setTimeout(otherRequest.callback, 0);
+          }
         }
-      }
-
-      return (0, _util.shadow)(this, "isSyncFontLoadingSupported", supported);
-    }
 
-    _queueLoadingCallback(callback) {
-      function completeRequest() {
-        (0, _util.assert)(!request.done, "completeRequest() cannot be called twice.");
-        request.done = true;
+        var context = this.loadingContext;
+        var request = {
+          id: "pdfjs-font-loading-".concat(context.nextRequestId++),
+          done: false,
+          complete: completeRequest,
+          callback: callback
+        };
+        context.requests.push(request);
+        return request;
+      }
+    }, {
+      key: "_prepareFontLoadEvent",
+      value: function _prepareFontLoadEvent(rules, fonts, request) {
+        function int32(data, offset) {
+          return data.charCodeAt(offset) << 24 | data.charCodeAt(offset + 1) << 16 | data.charCodeAt(offset + 2) << 8 | data.charCodeAt(offset + 3) & 0xff;
+        }
 
-        while (context.requests.length > 0 && context.requests[0].done) {
-          const otherRequest = context.requests.shift();
-          setTimeout(otherRequest.callback, 0);
+        function spliceString(s, offset, remove, insert) {
+          var chunk1 = s.substring(0, offset);
+          var chunk2 = s.substring(offset + remove);
+          return chunk1 + insert + chunk2;
         }
-      }
 
-      const context = this.loadingContext;
-      const request = {
-        id: `pdfjs-font-loading-${context.nextRequestId++}`,
-        done: false,
-        complete: completeRequest,
-        callback
-      };
-      context.requests.push(request);
-      return request;
-    }
+        var i, ii;
+        var canvas = document.createElement("canvas");
+        canvas.width = 1;
+        canvas.height = 1;
+        var ctx = canvas.getContext("2d");
+        var called = 0;
 
-    get _loadTestFont() {
-      const getLoadTestFont = function () {
-        return atob("T1RUTwALAIAAAwAwQ0ZGIDHtZg4AAAOYAAAAgUZGVE1lkzZwAAAEHAAAABxHREVGABQA" + "FQAABDgAAAAeT1MvMlYNYwkAAAEgAAAAYGNtYXABDQLUAAACNAAAAUJoZWFk/xVFDQAA" + "ALwAAAA2aGhlYQdkA+oAAAD0AAAAJGhtdHgD6AAAAAAEWAAAAAZtYXhwAAJQAAAAARgA" + "AAAGbmFtZVjmdH4AAAGAAAAAsXBvc3T/hgAzAAADeAAAACAAAQAAAAEAALZRFsRfDzz1" + "AAsD6AAAAADOBOTLAAAAAM4KHDwAAAAAA+gDIQAAAAgAAgAAAAAAAAABAAADIQAAAFoD" + "6AAAAAAD6AABAAAAAAAAAAAAAAAAAAAAAQAAUAAAAgAAAAQD6AH0AAUAAAKKArwAAACM" + "AooCvAAAAeAAMQECAAACAAYJAAAAAAAAAAAAAQAAAAAAAAAAAAAAAFBmRWQAwAAuAC4D" + "IP84AFoDIQAAAAAAAQAAAAAAAAAAACAAIAABAAAADgCuAAEAAAAAAAAAAQAAAAEAAAAA" + "AAEAAQAAAAEAAAAAAAIAAQAAAAEAAAAAAAMAAQAAAAEAAAAAAAQAAQAAAAEAAAAAAAUA" + "AQAAAAEAAAAAAAYAAQAAAAMAAQQJAAAAAgABAAMAAQQJAAEAAgABAAMAAQQJAAIAAgAB" + "AAMAAQQJAAMAAgABAAMAAQQJAAQAAgABAAMAAQQJAAUAAgABAAMAAQQJAAYAAgABWABY" + "AAAAAAAAAwAAAAMAAAAcAAEAAAAAADwAAwABAAAAHAAEACAAAAAEAAQAAQAAAC7//wAA" + "AC7////TAAEAAAAAAAABBgAAAQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" + "AAAAAAAAAAAAAAAAAAEAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" + "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" + "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" + "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" + "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAMAAAAAAAD/gwAyAAAAAQAAAAAAAAAAAAAAAAAA" + "AAABAAQEAAEBAQJYAAEBASH4DwD4GwHEAvgcA/gXBIwMAYuL+nz5tQXkD5j3CBLnEQAC" + "AQEBIVhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYAAABAQAADwACAQEEE/t3" + "Dov6fAH6fAT+fPp8+nwHDosMCvm1Cvm1DAz6fBQAAAAAAAABAAAAAMmJbzEAAAAAzgTj" + "FQAAAADOBOQpAAEAAAAAAAAADAAUAAQAAAABAAAAAgABAAAAAAAAAAAD6AAAAAAAAA==");
-      };
+        function isFontReady(name, callback) {
+          called++;
 
-      return (0, _util.shadow)(this, "_loadTestFont", getLoadTestFont());
-    }
+          if (called > 30) {
+            (0, _util.warn)("Load test font never loaded.");
+            callback();
+            return;
+          }
 
-    _prepareFontLoadEvent(rules, fonts, request) {
-      function int32(data, offset) {
-        return data.charCodeAt(offset) << 24 | data.charCodeAt(offset + 1) << 16 | data.charCodeAt(offset + 2) << 8 | data.charCodeAt(offset + 3) & 0xff;
-      }
+          ctx.font = "30px " + name;
+          ctx.fillText(".", 0, 20);
+          var imageData = ctx.getImageData(0, 0, 1, 1);
 
-      function spliceString(s, offset, remove, insert) {
-        const chunk1 = s.substring(0, offset);
-        const chunk2 = s.substring(offset + remove);
-        return chunk1 + insert + chunk2;
-      }
+          if (imageData.data[3] > 0) {
+            callback();
+            return;
+          }
 
-      let i, ii;
-      const canvas = document.createElement("canvas");
-      canvas.width = 1;
-      canvas.height = 1;
-      const ctx = canvas.getContext("2d");
-      let called = 0;
+          setTimeout(isFontReady.bind(null, name, callback));
+        }
 
-      function isFontReady(name, callback) {
-        called++;
+        var loadTestFontId = "lt".concat(Date.now()).concat(this.loadTestFontId++);
+        var data = this._loadTestFont;
+        var COMMENT_OFFSET = 976;
+        data = spliceString(data, COMMENT_OFFSET, loadTestFontId.length, loadTestFontId);
+        var CFF_CHECKSUM_OFFSET = 16;
+        var XXXX_VALUE = 0x58585858;
+        var checksum = int32(data, CFF_CHECKSUM_OFFSET);
 
-        if (called > 30) {
-          (0, _util.warn)("Load test font never loaded.");
-          callback();
-          return;
+        for (i = 0, ii = loadTestFontId.length - 3; i < ii; i += 4) {
+          checksum = checksum - XXXX_VALUE + int32(loadTestFontId, i) | 0;
         }
 
-        ctx.font = "30px " + name;
-        ctx.fillText(".", 0, 20);
-        const imageData = ctx.getImageData(0, 0, 1, 1);
-
-        if (imageData.data[3] > 0) {
-          callback();
-          return;
+        if (i < loadTestFontId.length) {
+          checksum = checksum - XXXX_VALUE + int32(loadTestFontId + "XXX", i) | 0;
         }
 
-        setTimeout(isFontReady.bind(null, name, callback));
-      }
+        data = spliceString(data, CFF_CHECKSUM_OFFSET, 4, (0, _util.string32)(checksum));
+        var url = "url(data:font/opentype;base64,".concat(btoa(data), ");");
+        var rule = "@font-face {font-family:\"".concat(loadTestFontId, "\";src:").concat(url, "}");
+        this.insertRule(rule);
+        var names = [];
 
-      const loadTestFontId = `lt${Date.now()}${this.loadTestFontId++}`;
-      let data = this._loadTestFont;
-      const COMMENT_OFFSET = 976;
-      data = spliceString(data, COMMENT_OFFSET, loadTestFontId.length, loadTestFontId);
-      const CFF_CHECKSUM_OFFSET = 16;
-      const XXXX_VALUE = 0x58585858;
-      let checksum = int32(data, CFF_CHECKSUM_OFFSET);
+        for (i = 0, ii = fonts.length; i < ii; i++) {
+          names.push(fonts[i].loadedName);
+        }
 
-      for (i = 0, ii = loadTestFontId.length - 3; i < ii; i += 4) {
-        checksum = checksum - XXXX_VALUE + int32(loadTestFontId, i) | 0;
-      }
+        names.push(loadTestFontId);
+        var div = document.createElement("div");
+        div.style.visibility = "hidden";
+        div.style.width = div.style.height = "10px";
+        div.style.position = "absolute";
+        div.style.top = div.style.left = "0px";
+
+        for (i = 0, ii = names.length; i < ii; ++i) {
+          var span = document.createElement("span");
+          span.textContent = "Hi";
+          span.style.fontFamily = names[i];
+          div.appendChild(span);
+        }
 
-      if (i < loadTestFontId.length) {
-        checksum = checksum - XXXX_VALUE + int32(loadTestFontId + "XXX", i) | 0;
+        document.body.appendChild(div);
+        isFontReady(loadTestFontId, function () {
+          document.body.removeChild(div);
+          request.complete();
+        });
       }
+    }, {
+      key: "isSyncFontLoadingSupported",
+      get: function get() {
+        var supported = false;
 
-      data = spliceString(data, CFF_CHECKSUM_OFFSET, 4, (0, _util.string32)(checksum));
-      const url = `url(data:font/opentype;base64,${btoa(data)});`;
-      const rule = `@font-face {font-family:"${loadTestFontId}";src:${url}}`;
-      this.insertRule(rule);
-      const names = [];
-
-      for (i = 0, ii = fonts.length; i < ii; i++) {
-        names.push(fonts[i].loadedName);
-      }
+        if (typeof navigator === "undefined") {
+          supported = true;
+        } else {
+          var m = /Mozilla\/5.0.*?rv:(\d+).*? Gecko/.exec(navigator.userAgent);
 
-      names.push(loadTestFontId);
-      const div = document.createElement("div");
-      div.style.visibility = "hidden";
-      div.style.width = div.style.height = "10px";
-      div.style.position = "absolute";
-      div.style.top = div.style.left = "0px";
+          if (m && m[1] >= 14) {
+            supported = true;
+          }
+        }
 
-      for (i = 0, ii = names.length; i < ii; ++i) {
-        const span = document.createElement("span");
-        span.textContent = "Hi";
-        span.style.fontFamily = names[i];
-        div.appendChild(span);
+        return (0, _util.shadow)(this, "isSyncFontLoadingSupported", supported);
       }
+    }, {
+      key: "_loadTestFont",
+      get: function get() {
+        var getLoadTestFont = function getLoadTestFont() {
+          return atob("T1RUTwALAIAAAwAwQ0ZGIDHtZg4AAAOYAAAAgUZGVE1lkzZwAAAEHAAAABxHREVGABQA" + "FQAABDgAAAAeT1MvMlYNYwkAAAEgAAAAYGNtYXABDQLUAAACNAAAAUJoZWFk/xVFDQAA" + "ALwAAAA2aGhlYQdkA+oAAAD0AAAAJGhtdHgD6AAAAAAEWAAAAAZtYXhwAAJQAAAAARgA" + "AAAGbmFtZVjmdH4AAAGAAAAAsXBvc3T/hgAzAAADeAAAACAAAQAAAAEAALZRFsRfDzz1" + "AAsD6AAAAADOBOTLAAAAAM4KHDwAAAAAA+gDIQAAAAgAAgAAAAAAAAABAAADIQAAAFoD" + "6AAAAAAD6AABAAAAAAAAAAAAAAAAAAAAAQAAUAAAAgAAAAQD6AH0AAUAAAKKArwAAACM" + "AooCvAAAAeAAMQECAAACAAYJAAAAAAAAAAAAAQAAAAAAAAAAAAAAAFBmRWQAwAAuAC4D" + "IP84AFoDIQAAAAAAAQAAAAAAAAAAACAAIAABAAAADgCuAAEAAAAAAAAAAQAAAAEAAAAA" + "AAEAAQAAAAEAAAAAAAIAAQAAAAEAAAAAAAMAAQAAAAEAAAAAAAQAAQAAAAEAAAAAAAUA" + "AQAAAAEAAAAAAAYAAQAAAAMAAQQJAAAAAgABAAMAAQQJAAEAAgABAAMAAQQJAAIAAgAB" + "AAMAAQQJAAMAAgABAAMAAQQJAAQAAgABAAMAAQQJAAUAAgABAAMAAQQJAAYAAgABWABY" + "AAAAAAAAAwAAAAMAAAAcAAEAAAAAADwAAwABAAAAHAAEACAAAAAEAAQAAQAAAC7//wAA" + "AC7////TAAEAAAAAAAABBgAAAQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" + "AAAAAAAAAAAAAAAAAAEAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" + "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" + "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" + "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" + "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAMAAAAAAAD/gwAyAAAAAQAAAAAAAAAAAAAAAAAA" + "AAABAAQEAAEBAQJYAAEBASH4DwD4GwHEAvgcA/gXBIwMAYuL+nz5tQXkD5j3CBLnEQAC" + "AQEBIVhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYAAABAQAADwACAQEEE/t3" + "Dov6fAH6fAT+fPp8+nwHDosMCvm1Cvm1DAz6fBQAAAAAAAABAAAAAMmJbzEAAAAAzgTj" + "FQAAAADOBOQpAAEAAAAAAAAADAAUAAQAAAABAAAAAgABAAAAAAAAAAAD6AAAAAAAAA==");
+        };
 
-      document.body.appendChild(div);
-      isFontReady(loadTestFontId, function () {
-        document.body.removeChild(div);
-        request.complete();
-      });
-    }
+        return (0, _util.shadow)(this, "_loadTestFont", getLoadTestFont());
+      }
+    }]);
 
-  };
+    return GenericFontLoader;
+  }(BaseFontLoader);
 }
 
-class FontFaceObject {
-  constructor(translatedData, {
-    isEvalSupported = true,
-    disableFontFace = false,
-    ignoreErrors = false,
-    onUnsupportedFeature = null,
-    fontRegistry = null
-  }) {
+var FontFaceObject = /*#__PURE__*/function () {
+  function FontFaceObject(translatedData, _ref2) {
+    var _ref2$isEvalSupported = _ref2.isEvalSupported,
+        isEvalSupported = _ref2$isEvalSupported === void 0 ? true : _ref2$isEvalSupported,
+        _ref2$disableFontFace = _ref2.disableFontFace,
+        disableFontFace = _ref2$disableFontFace === void 0 ? false : _ref2$disableFontFace,
+        _ref2$ignoreErrors = _ref2.ignoreErrors,
+        ignoreErrors = _ref2$ignoreErrors === void 0 ? false : _ref2$ignoreErrors,
+        _ref2$onUnsupportedFe = _ref2.onUnsupportedFeature,
+        onUnsupportedFeature = _ref2$onUnsupportedFe === void 0 ? null : _ref2$onUnsupportedFe,
+        _ref2$fontRegistry = _ref2.fontRegistry,
+        fontRegistry = _ref2$fontRegistry === void 0 ? null : _ref2$fontRegistry;
+
+    _classCallCheck(this, FontFaceObject);
+
     this.compiledGlyphs = Object.create(null);
 
-    for (const i in translatedData) {
+    for (var i in translatedData) {
       this[i] = translatedData[i];
     }
 
@@ -4100,98 +14930,104 @@ class FontFaceObject {
     this.fontRegistry = fontRegistry;
   }
 
-  createNativeFontFace() {
-    if (!this.data || this.disableFontFace) {
-      return null;
-    }
-
-    const nativeFontFace = new FontFace(this.loadedName, this.data, {});
+  _createClass(FontFaceObject, [{
+    key: "createNativeFontFace",
+    value: function createNativeFontFace() {
+      if (!this.data || this.disableFontFace) {
+        return null;
+      }
 
-    if (this.fontRegistry) {
-      this.fontRegistry.registerFont(this);
-    }
+      var nativeFontFace = new FontFace(this.loadedName, this.data, {});
 
-    return nativeFontFace;
-  }
+      if (this.fontRegistry) {
+        this.fontRegistry.registerFont(this);
+      }
 
-  createFontFaceRule() {
-    if (!this.data || this.disableFontFace) {
-      return null;
+      return nativeFontFace;
     }
+  }, {
+    key: "createFontFaceRule",
+    value: function createFontFaceRule() {
+      if (!this.data || this.disableFontFace) {
+        return null;
+      }
 
-    const data = (0, _util.bytesToString)(new Uint8Array(this.data));
-    const url = `url(data:${this.mimetype};base64,${btoa(data)});`;
-    const rule = `@font-face {font-family:"${this.loadedName}";src:${url}}`;
-
-    if (this.fontRegistry) {
-      this.fontRegistry.registerFont(this, url);
-    }
+      var data = (0, _util.bytesToString)(new Uint8Array(this.data));
+      var url = "url(data:".concat(this.mimetype, ";base64,").concat(btoa(data), ");");
+      var rule = "@font-face {font-family:\"".concat(this.loadedName, "\";src:").concat(url, "}");
 
-    return rule;
-  }
+      if (this.fontRegistry) {
+        this.fontRegistry.registerFont(this, url);
+      }
 
-  getPathGenerator(objs, character) {
-    if (this.compiledGlyphs[character] !== undefined) {
-      return this.compiledGlyphs[character];
+      return rule;
     }
+  }, {
+    key: "getPathGenerator",
+    value: function getPathGenerator(objs, character) {
+      if (this.compiledGlyphs[character] !== undefined) {
+        return this.compiledGlyphs[character];
+      }
 
-    let cmds, current;
+      var cmds, current;
 
-    try {
-      cmds = objs.get(this.loadedName + "_path_" + character);
-    } catch (ex) {
-      if (!this.ignoreErrors) {
-        throw ex;
-      }
+      try {
+        cmds = objs.get(this.loadedName + "_path_" + character);
+      } catch (ex) {
+        if (!this.ignoreErrors) {
+          throw ex;
+        }
 
-      if (this._onUnsupportedFeature) {
-        this._onUnsupportedFeature({
-          featureId: _util.UNSUPPORTED_FEATURES.errorFontGetPath
-        });
+        if (this._onUnsupportedFeature) {
+          this._onUnsupportedFeature({
+            featureId: _util.UNSUPPORTED_FEATURES.errorFontGetPath
+          });
+        }
+
+        (0, _util.warn)("getPathGenerator - ignoring character: \"".concat(ex, "\"."));
+        return this.compiledGlyphs[character] = function (c, size) {};
       }
 
-      (0, _util.warn)(`getPathGenerator - ignoring character: "${ex}".`);
-      return this.compiledGlyphs[character] = function (c, size) {};
-    }
+      if (this.isEvalSupported && _util.IsEvalSupportedCached.value) {
+        var args,
+            js = "";
 
-    if (this.isEvalSupported && _util.IsEvalSupportedCached.value) {
-      let args,
-          js = "";
+        for (var i = 0, ii = cmds.length; i < ii; i++) {
+          current = cmds[i];
 
-      for (let i = 0, ii = cmds.length; i < ii; i++) {
-        current = cmds[i];
+          if (current.args !== undefined) {
+            args = current.args.join(",");
+          } else {
+            args = "";
+          }
 
-        if (current.args !== undefined) {
-          args = current.args.join(",");
-        } else {
-          args = "";
+          js += "c." + current.cmd + "(" + args + ");\n";
         }
 
-        js += "c." + current.cmd + "(" + args + ");\n";
+        return this.compiledGlyphs[character] = new Function("c", "size", js);
       }
 
-      return this.compiledGlyphs[character] = new Function("c", "size", js);
-    }
+      return this.compiledGlyphs[character] = function (c, size) {
+        for (var _i = 0, _ii = cmds.length; _i < _ii; _i++) {
+          current = cmds[_i];
 
-    return this.compiledGlyphs[character] = function (c, size) {
-      for (let i = 0, ii = cmds.length; i < ii; i++) {
-        current = cmds[i];
+          if (current.cmd === "scale") {
+            current.args = [size, -size];
+          }
 
-        if (current.cmd === "scale") {
-          current.args = [size, -size];
+          c[current.cmd].apply(c, current.args);
         }
+      };
+    }
+  }]);
 
-        c[current.cmd].apply(c, current.args);
-      }
-    };
-  }
-
-}
+  return FontFaceObject;
+}();
 
 exports.FontFaceObject = FontFaceObject;
 
 /***/ }),
-/* 7 */
+/* 200 */
 /***/ (function(module, exports, __w_pdfjs_require__) {
 
 "use strict";
@@ -4202,9 +15038,9 @@ Object.defineProperty(exports, "__esModule", {
 });
 exports.apiCompatibilityParams = void 0;
 
-var _is_node = __w_pdfjs_require__(4);
+var _is_node = __w_pdfjs_require__(7);
 
-const compatibilityParams = Object.create(null);
+var compatibilityParams = Object.create(null);
 {
   (function checkFontFace() {
     if (_is_node.isNodeJS) {
@@ -4212,11 +15048,11 @@ const compatibilityParams = Object.create(null);
     }
   })();
 }
-const apiCompatibilityParams = Object.freeze(compatibilityParams);
+var apiCompatibilityParams = Object.freeze(compatibilityParams);
 exports.apiCompatibilityParams = apiCompatibilityParams;
 
 /***/ }),
-/* 8 */
+/* 201 */
 /***/ (function(module, exports, __w_pdfjs_require__) {
 
 "use strict";
@@ -4227,9 +15063,15 @@ Object.defineProperty(exports, "__esModule", {
 });
 exports.CanvasGraphics = void 0;
 
-var _util = __w_pdfjs_require__(2);
+var _util = __w_pdfjs_require__(5);
+
+var _pattern_helper = __w_pdfjs_require__(202);
+
+function _createForOfIteratorHelper(o, allowArrayLike) { var it; if (typeof Symbol === "undefined" || o[Symbol.iterator] == null) { if (Array.isArray(o) || (it = _unsupportedIterableToArray(o)) || allowArrayLike && o && typeof o.length === "number") { if (it) o = it; var i = 0; var F = function F() {}; return { s: F, n: function n() { if (i >= o.length) return { done: true }; return { done: false, value: o[i++] }; }, e: function e(_e) { throw _e; }, f: F }; } throw new TypeError("Invalid attempt to iterate non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method."); } var normalCompletion = true, didErr = false, err; return { s: function s() { it = o[Symbol.iterator](); }, n: function n() { var step = it.next(); normalCompletion = step.done; return step; }, e: function e(_e2) { didErr = true; err = _e2; }, f: function f() { try { if (!normalCompletion && it["return"] != null) it["return"](); } finally { if (didErr) throw err; } } }; }
 
-var _pattern_helper = __w_pdfjs_require__(9);
+function _unsupportedIterableToArray(o, minLen) { if (!o) return; if (typeof o === "string") return _arrayLikeToArray(o, minLen); var n = Object.prototype.toString.call(o).slice(8, -1); if (n === "Object" && o.constructor) n = o.constructor.name; if (n === "Map" || n === "Set") return Array.from(o); if (n === "Arguments" || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(n)) return _arrayLikeToArray(o, minLen); }
+
+function _arrayLikeToArray(arr, len) { if (len == null || len > arr.length) len = arr.length; for (var i = 0, arr2 = new Array(len); i < len; i++) { arr2[i] = arr[i]; } return arr2; }
 
 var MIN_FONT_SIZE = 16;
 var MAX_FONT_SIZE = 100;
@@ -4357,15 +15199,13 @@ var CachedCanvases = function CachedCanvasesClosure() {
 
       return canvasEntry;
     },
-
-    clear() {
+    clear: function clear() {
       for (var id in this.cache) {
         var canvasEntry = this.cache[id];
         this.canvasFactory.destroy(canvasEntry);
         delete this.cache[id];
       }
     }
-
   };
   return CachedCanvases;
 }();
@@ -4525,17 +15365,17 @@ function compileType3Glyph(imgData) {
     --i;
   }
 
-  var drawOutline = function (c) {
+  var drawOutline = function drawOutline(c) {
     c.save();
     c.scale(1 / width, -1 / height);
     c.translate(0, -height);
     c.beginPath();
 
-    for (let k = 0, kk = outlines.length; k < kk; k++) {
+    for (var k = 0, kk = outlines.length; k < kk; k++) {
       var o = outlines[k];
       c.moveTo(o[0], o[1]);
 
-      for (let l = 2, ll = o.length; l < ll; l += 2) {
+      for (var l = 2, ll = o.length; l < ll; l += 2) {
         c.lineTo(o[l], o[l + 1]);
       }
     }
@@ -4727,7 +15567,7 @@ var CanvasGraphics = function CanvasGraphicsClosure() {
         ctx.putImageData(chunkImgData, 0, i * FULL_CHUNK_HEIGHT);
       }
     } else {
-      throw new Error(`bad image kind: ${imgData.kind}`);
+      throw new Error("bad image kind: ".concat(imgData.kind));
     }
   }
 
@@ -4875,12 +15715,12 @@ var CanvasGraphics = function CanvasGraphicsClosure() {
     var backdrop = smask.backdrop || null;
 
     if (!smask.transferMap && webGLContext.isEnabled) {
-      const composed = webGLContext.composeSMask({
+      var composed = webGLContext.composeSMask({
         layer: layerCtx.canvas,
-        mask,
+        mask: mask,
         properties: {
           subtype: smask.subtype,
-          backdrop
+          backdrop: backdrop
         }
       });
       ctx.setTransform(1, 0, 0, 1, 0, 0);
@@ -4897,12 +15737,13 @@ var CanvasGraphics = function CanvasGraphicsClosure() {
   var NORMAL_CLIP = {};
   var EO_CLIP = {};
   CanvasGraphics.prototype = {
-    beginDrawing({
-      transform,
-      viewport,
-      transparency = false,
-      background = null
-    }) {
+    beginDrawing: function beginDrawing(_ref) {
+      var transform = _ref.transform,
+          viewport = _ref.viewport,
+          _ref$transparency = _ref.transparency,
+          transparency = _ref$transparency === void 0 ? false : _ref$transparency,
+          _ref$background = _ref.background,
+          background = _ref$background === void 0 ? null : _ref$background;
       var width = this.ctx.canvas.width;
       var height = this.ctx.canvas.height;
       this.ctx.save();
@@ -4933,7 +15774,6 @@ var CanvasGraphics = function CanvasGraphicsClosure() {
         this.imageLayer.beginLayout();
       }
     },
-
     executeOperatorList: function CanvasGraphics_executeOperatorList(operatorList, executionStartIdx, continueCallback, stepper) {
       var argsArray = operatorList.argsArray;
       var fnArray = operatorList.fnArray;
@@ -4962,13 +15802,23 @@ var CanvasGraphics = function CanvasGraphicsClosure() {
         if (fnId !== _util.OPS.dependency) {
           this[fnId].apply(this, argsArray[i]);
         } else {
-          for (const depObjId of argsArray[i]) {
-            const objsPool = depObjId.startsWith("g_") ? commonObjs : objs;
+          var _iterator = _createForOfIteratorHelper(argsArray[i]),
+              _step;
 
-            if (!objsPool.has(depObjId)) {
-              objsPool.get(depObjId, continueCallback);
-              return i;
+          try {
+            for (_iterator.s(); !(_step = _iterator.n()).done;) {
+              var depObjId = _step.value;
+              var objsPool = depObjId.startsWith("g_") ? commonObjs : objs;
+
+              if (!objsPool.has(depObjId)) {
+                objsPool.get(depObjId, continueCallback);
+                return i;
+              }
             }
+          } catch (err) {
+            _iterator.e(err);
+          } finally {
+            _iterator.f();
           }
         }
 
@@ -5032,11 +15882,8 @@ var CanvasGraphics = function CanvasGraphicsClosure() {
         ctx.lineDashOffset = dashPhase;
       }
     },
-
-    setRenderingIntent(intent) {},
-
-    setFlatness(flatness) {},
-
+    setRenderingIntent: function setRenderingIntent(intent) {},
+    setFlatness: function setFlatness(flatness) {},
     setGState: function CanvasGraphics_setGState(states) {
       for (var i = 0, ii = states.length; i < ii; i++) {
         var state = states[i];
@@ -5277,9 +16124,9 @@ var CanvasGraphics = function CanvasGraphicsClosure() {
 
       if (strokeColor && strokeColor.hasOwnProperty("type") && strokeColor.type === "Pattern") {
         ctx.save();
-        const transform = ctx.mozCurrentTransform;
+        var transform = ctx.mozCurrentTransform;
 
-        const scale = _util.Util.singularValueDecompose2dScale(transform)[0];
+        var scale = _util.Util.singularValueDecompose2dScale(transform)[0];
 
         ctx.strokeStyle = strokeColor.getPattern(ctx, this);
         ctx.lineWidth = Math.max(this.getSinglePixelWidth() * MIN_WIDTH_FACTOR, this.current.lineWidth * scale);
@@ -5411,7 +16258,7 @@ var CanvasGraphics = function CanvasGraphicsClosure() {
       var current = this.current;
 
       if (!fontObj) {
-        throw new Error(`Can't find font for ${fontRefName}`);
+        throw new Error("Can't find font for ".concat(fontRefName));
       }
 
       current.fontMatrix = fontObj.fontMatrix ? fontObj.fontMatrix : _util.FONT_IDENTITY_MATRIX;
@@ -5435,7 +16282,7 @@ var CanvasGraphics = function CanvasGraphicsClosure() {
       }
 
       var name = fontObj.loadedName || "sans-serif";
-      let bold = "normal";
+      var bold = "normal";
 
       if (fontObj.black) {
         bold = "900";
@@ -5444,8 +16291,8 @@ var CanvasGraphics = function CanvasGraphicsClosure() {
       }
 
       var italic = fontObj.italic ? "italic" : "normal";
-      var typeface = `"${name}", ${fontObj.fallbackName}`;
-      let browserFontSize = size;
+      var typeface = "\"".concat(name, "\", ").concat(fontObj.fallbackName);
+      var browserFontSize = size;
 
       if (size < MIN_FONT_SIZE) {
         browserFontSize = MIN_FONT_SIZE;
@@ -5454,7 +16301,7 @@ var CanvasGraphics = function CanvasGraphicsClosure() {
       }
 
       this.current.fontSizeScale = size / browserFontSize;
-      this.ctx.font = `${italic} ${bold} ${browserFontSize}px ${typeface}`;
+      this.ctx.font = "".concat(italic, " ").concat(bold, " ").concat(browserFontSize, "px ").concat(typeface);
     },
     setTextRenderingMode: function CanvasGraphics_setTextRenderingMode(mode) {
       this.current.textRenderingMode = mode;
@@ -5479,8 +16326,7 @@ var CanvasGraphics = function CanvasGraphicsClosure() {
     nextLine: function CanvasGraphics_nextLine() {
       this.moveText(0, this.current.leading);
     },
-
-    paintChar(character, x, y, patternTransform) {
+    paintChar: function paintChar(character, x, y, patternTransform) {
       var ctx = this.ctx;
       var current = this.current;
       var font = current.font;
@@ -5488,7 +16334,7 @@ var CanvasGraphics = function CanvasGraphicsClosure() {
       var fontSize = current.fontSize / current.fontSizeScale;
       var fillStrokeMode = textRenderingMode & _util.TextRenderingMode.FILL_STROKE_MASK;
       var isAddToPathSet = !!(textRenderingMode & _util.TextRenderingMode.ADD_TO_PATH_FLAG);
-      const patternFill = current.patternFill && !font.missingFile;
+      var patternFill = current.patternFill && !font.missingFile;
       var addToPath;
 
       if (font.disableFontFace || isAddToPathSet || patternFill) {
@@ -5528,18 +16374,18 @@ var CanvasGraphics = function CanvasGraphicsClosure() {
         var paths = this.pendingTextPaths || (this.pendingTextPaths = []);
         paths.push({
           transform: ctx.mozCurrentTransform,
-          x,
-          y,
-          fontSize,
-          addToPath
+          x: x,
+          y: y,
+          fontSize: fontSize,
+          addToPath: addToPath
         });
       }
     },
 
     get isFontSubpixelAAEnabled() {
-      const {
-        context: ctx
-      } = this.cachedCanvases.getCanvas("isFontSubpixelAAEnabled", 10, 10);
+      var _this$cachedCanvases$ = this.cachedCanvases.getCanvas("isFontSubpixelAAEnabled", 10, 10),
+          ctx = _this$cachedCanvases$.context;
+
       ctx.scale(1.5, 1);
       ctx.fillText("I", 0, 10);
       var data = ctx.getImageData(0, 0, 10, 10).data;
@@ -5582,11 +16428,11 @@ var CanvasGraphics = function CanvasGraphicsClosure() {
       var widthAdvanceScale = fontSize * current.fontMatrix[0];
       var simpleFillText = current.textRenderingMode === _util.TextRenderingMode.FILL && !font.disableFontFace && !current.patternFill;
       ctx.save();
-      let patternTransform;
+      var patternTransform;
 
       if (current.patternFill) {
         ctx.save();
-        const pattern = current.fillColor.getPattern(ctx, this);
+        var pattern = current.fillColor.getPattern(ctx, this);
         patternTransform = ctx.mozCurrentTransform;
         ctx.restore();
         ctx.fillStyle = pattern;
@@ -5743,7 +16589,7 @@ var CanvasGraphics = function CanvasGraphicsClosure() {
         var operatorList = font.charProcOperatorList[glyph.operatorListId];
 
         if (!operatorList) {
-          (0, _util.warn)(`Type3 character "${glyph.operatorListId}" is not available.`);
+          (0, _util.warn)("Type3 character \"".concat(glyph.operatorListId, "\" is not available."));
           continue;
         }
 
@@ -5771,14 +16617,16 @@ var CanvasGraphics = function CanvasGraphicsClosure() {
       this.endPath();
     },
     getColorN_Pattern: function CanvasGraphics_getColorN_Pattern(IR) {
+      var _this = this;
+
       var pattern;
 
       if (IR[0] === "TilingPattern") {
         var color = IR[1];
         var baseTransform = this.baseTransform || this.ctx.mozCurrentTransform.slice();
         var canvasGraphicsFactory = {
-          createCanvasGraphics: ctx => {
-            return new CanvasGraphics(ctx, this.commonObjs, this.objs, this.canvasFactory, this.webGLContext);
+          createCanvasGraphics: function createCanvasGraphics(ctx) {
+            return new CanvasGraphics(ctx, _this.commonObjs, _this.objs, _this.canvasFactory, _this.webGLContext);
           }
         };
         pattern = new _pattern_helper.TilingPattern(IR, color, this.ctx, canvasGraphicsFactory, baseTransform);
@@ -5926,10 +16774,10 @@ var CanvasGraphics = function CanvasGraphicsClosure() {
         this.smaskStack.push({
           canvas: scratchCanvas.canvas,
           context: groupCtx,
-          offsetX,
-          offsetY,
-          scaleX,
-          scaleY,
+          offsetX: offsetX,
+          offsetY: offsetY,
+          scaleX: scaleX,
+          scaleY: scaleY,
           subtype: group.smask.subtype,
           backdrop: group.smask.backdrop,
           transferMap: group.smask.transferMap || null,
@@ -6008,8 +16856,8 @@ var CanvasGraphics = function CanvasGraphicsClosure() {
         if (width <= MAX_SIZE_TO_COMPILE && height <= MAX_SIZE_TO_COMPILE) {
           glyph.compiled = compileType3Glyph({
             data: img.data,
-            width,
-            height
+            width: width,
+            height: height
           });
         } else {
           glyph.compiled = null;
@@ -6079,7 +16927,7 @@ var CanvasGraphics = function CanvasGraphicsClosure() {
       }
     },
     paintImageXObject: function CanvasGraphics_paintImageXObject(objId) {
-      const imgData = objId.startsWith("g_") ? this.commonObjs.get(objId) : this.objs.get(objId);
+      var imgData = objId.startsWith("g_") ? this.commonObjs.get(objId) : this.objs.get(objId);
 
       if (!imgData) {
         (0, _util.warn)("Dependent image isn't ready yet");
@@ -6089,7 +16937,7 @@ var CanvasGraphics = function CanvasGraphicsClosure() {
       this.paintInlineImageXObject(imgData);
     },
     paintImageXObjectRepeat: function CanvasGraphics_paintImageXObjectRepeat(objId, scaleX, scaleY, positions) {
-      const imgData = objId.startsWith("g_") ? this.commonObjs.get(objId) : this.objs.get(objId);
+      var imgData = objId.startsWith("g_") ? this.commonObjs.get(objId) : this.objs.get(objId);
 
       if (!imgData) {
         (0, _util.warn)("Dependent image isn't ready yet");
@@ -6169,7 +17017,7 @@ var CanvasGraphics = function CanvasGraphicsClosure() {
       if (this.imageLayer) {
         var position = this.getCanvasPosition(0, -height);
         this.imageLayer.appendImage({
-          imgData,
+          imgData: imgData,
           left: position[0],
           top: position[1],
           width: width / currentTransform[0],
@@ -6197,7 +17045,7 @@ var CanvasGraphics = function CanvasGraphicsClosure() {
         if (this.imageLayer) {
           var position = this.getCanvasPosition(entry.x, entry.y);
           this.imageLayer.appendImage({
-            imgData,
+            imgData: imgData,
             left: position[0],
             top: position[1],
             width: w,
@@ -6236,16 +17084,14 @@ var CanvasGraphics = function CanvasGraphicsClosure() {
 
       ctx.beginPath();
     },
-
-    getSinglePixelWidth(scale) {
+    getSinglePixelWidth: function getSinglePixelWidth(scale) {
       if (this._cachedGetSinglePixelWidth === null) {
-        const inverse = this.ctx.mozCurrentTransformInverse;
+        var inverse = this.ctx.mozCurrentTransformInverse;
         this._cachedGetSinglePixelWidth = Math.sqrt(Math.max(inverse[0] * inverse[0] + inverse[1] * inverse[1], inverse[2] * inverse[2] + inverse[3] * inverse[3]));
       }
 
       return this._cachedGetSinglePixelWidth;
     },
-
     getCanvasPosition: function CanvasGraphics_getCanvasPosition(x, y) {
       var transform = this.ctx.mozCurrentTransform;
       return [transform[0] * x + transform[2] * y + transform[4], transform[1] * x + transform[3] * y + transform[5]];
@@ -6262,7 +17108,7 @@ var CanvasGraphics = function CanvasGraphicsClosure() {
 exports.CanvasGraphics = CanvasGraphics;
 
 /***/ }),
-/* 9 */
+/* 202 */
 /***/ (function(module, exports, __w_pdfjs_require__) {
 
 "use strict";
@@ -6274,7 +17120,7 @@ Object.defineProperty(exports, "__esModule", {
 exports.getShadingPatternFromIR = getShadingPatternFromIR;
 exports.TilingPattern = void 0;
 
-var _util = __w_pdfjs_require__(2);
+var _util = __w_pdfjs_require__(5);
 
 var ShadingIRs = {};
 
@@ -6283,9 +17129,9 @@ function applyBoundingBox(ctx, bbox) {
     return;
   }
 
-  const width = bbox[2] - bbox[0];
-  const height = bbox[3] - bbox[1];
-  const region = new Path2D();
+  var width = bbox[2] - bbox[0];
+  var height = bbox[3] - bbox[1];
+  var region = new Path2D();
   region.rect(bbox[0], bbox[1], width, height);
   ctx.clip(region);
 }
@@ -6384,38 +17230,38 @@ var createMeshCanvas = function createMeshCanvasClosure() {
 
     for (var y = minY; y <= maxY; y++) {
       if (y < y2) {
-        let k;
+        var _k = void 0;
 
         if (y < y1) {
-          k = 0;
+          _k = 0;
         } else if (y1 === y2) {
-          k = 1;
+          _k = 1;
         } else {
-          k = (y1 - y) / (y1 - y2);
+          _k = (y1 - y) / (y1 - y2);
         }
 
-        xa = x1 - (x1 - x2) * k;
-        car = c1r - (c1r - c2r) * k;
-        cag = c1g - (c1g - c2g) * k;
-        cab = c1b - (c1b - c2b) * k;
+        xa = x1 - (x1 - x2) * _k;
+        car = c1r - (c1r - c2r) * _k;
+        cag = c1g - (c1g - c2g) * _k;
+        cab = c1b - (c1b - c2b) * _k;
       } else {
-        let k;
+        var _k2 = void 0;
 
         if (y > y3) {
-          k = 1;
+          _k2 = 1;
         } else if (y2 === y3) {
-          k = 0;
+          _k2 = 0;
         } else {
-          k = (y2 - y) / (y2 - y3);
+          _k2 = (y2 - y) / (y2 - y3);
         }
 
-        xa = x2 - (x2 - x3) * k;
-        car = c2r - (c2r - c3r) * k;
-        cag = c2g - (c2g - c3g) * k;
-        cab = c2b - (c2b - c3b) * k;
+        xa = x2 - (x2 - x3) * _k2;
+        car = c2r - (c2r - c3r) * _k2;
+        cag = c2g - (c2g - c3g) * _k2;
+        cab = c2b - (c2b - c3b) * _k2;
       }
 
-      let k;
+      var k = void 0;
 
       if (y < y1) {
         k = 0;
@@ -6497,8 +17343,8 @@ var createMeshCanvas = function createMeshCanvasClosure() {
     var scaleX = boundsWidth / width;
     var scaleY = boundsHeight / height;
     var context = {
-      coords,
-      colors,
+      coords: coords,
+      colors: colors,
       offsetX: -offsetX,
       offsetY: -offsetY,
       scaleX: 1 / scaleX,
@@ -6510,11 +17356,11 @@ var createMeshCanvas = function createMeshCanvasClosure() {
 
     if (webGLContext.isEnabled) {
       canvas = webGLContext.drawFigures({
-        width,
-        height,
-        backgroundColor,
-        figures,
-        context
+        width: width,
+        height: height,
+        backgroundColor: backgroundColor,
+        figures: figures,
+        context: context
       });
       tmpCanvas = cachedCanvases.getCanvas("mesh", paddedWidth, paddedHeight, false);
       tmpCanvas.context.drawImage(canvas, BORDER_SIZE, BORDER_SIZE);
@@ -6544,11 +17390,11 @@ var createMeshCanvas = function createMeshCanvasClosure() {
     }
 
     return {
-      canvas,
+      canvas: canvas,
       offsetX: offsetX - BORDER_SIZE * scaleX,
       offsetY: offsetY - BORDER_SIZE * scaleY,
-      scaleX,
-      scaleY
+      scaleX: scaleX,
+      scaleY: scaleY
     };
   }
 
@@ -6614,7 +17460,7 @@ function getShadingPatternFromIR(raw) {
   var shadingIR = ShadingIRs[raw[0]];
 
   if (!shadingIR) {
-    throw new Error(`Unknown IR type: ${raw[0]}`);
+    throw new Error("Unknown IR type: ".concat(raw[0]));
   }
 
   return shadingIR.fromIR(raw);
@@ -6690,8 +17536,8 @@ var TilingPattern = function TilingPatternClosure() {
       }
 
       return {
-        scale,
-        size
+        scale: scale,
+        size: size
       };
     },
     clipBbox: function clipBbox(graphics, bbox, x0, y0, x1, y1) {
@@ -6704,8 +17550,8 @@ var TilingPattern = function TilingPatternClosure() {
       }
     },
     setFillAndStrokeStyleToContext: function setFillAndStrokeStyleToContext(graphics, paintType, color) {
-      const context = graphics.ctx,
-            current = graphics.current;
+      var context = graphics.ctx,
+          current = graphics.current;
 
       switch (paintType) {
         case PaintType.COLORED:
@@ -6726,7 +17572,7 @@ var TilingPattern = function TilingPatternClosure() {
           break;
 
         default:
-          throw new _util.FormatError(`Unsupported paint type: ${paintType}`);
+          throw new _util.FormatError("Unsupported paint type: ".concat(paintType));
       }
     },
     getPattern: function TilingPattern_getPattern(ctx, owner) {
@@ -6743,7 +17589,7 @@ var TilingPattern = function TilingPatternClosure() {
 exports.TilingPattern = TilingPattern;
 
 /***/ }),
-/* 10 */
+/* 203 */
 /***/ (function(module, exports, __w_pdfjs_require__) {
 
 "use strict";
@@ -6753,13 +17599,13 @@ Object.defineProperty(exports, "__esModule", {
   value: true
 });
 exports.GlobalWorkerOptions = void 0;
-const GlobalWorkerOptions = Object.create(null);
+var GlobalWorkerOptions = Object.create(null);
 exports.GlobalWorkerOptions = GlobalWorkerOptions;
 GlobalWorkerOptions.workerPort = GlobalWorkerOptions.workerPort === undefined ? null : GlobalWorkerOptions.workerPort;
 GlobalWorkerOptions.workerSrc = GlobalWorkerOptions.workerSrc === undefined ? "" : GlobalWorkerOptions.workerSrc;
 
 /***/ }),
-/* 11 */
+/* 204 */
 /***/ (function(module, exports, __w_pdfjs_require__) {
 
 "use strict";
@@ -6770,14 +17616,30 @@ Object.defineProperty(exports, "__esModule", {
 });
 exports.MessageHandler = void 0;
 
-var _util = __w_pdfjs_require__(2);
+var _regenerator = _interopRequireDefault(__w_pdfjs_require__(2));
 
-const CallbackKind = {
+var _util = __w_pdfjs_require__(5);
+
+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; }
+
+function _typeof(obj) { "@babel/helpers - typeof"; 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); }
+
+var CallbackKind = {
   UNKNOWN: 0,
   DATA: 1,
   ERROR: 2
 };
-const StreamKind = {
+var StreamKind = {
   UNKNOWN: 0,
   CANCEL: 1,
   CANCEL_COMPLETE: 2,
@@ -6790,7 +17652,7 @@ const StreamKind = {
 };
 
 function wrapReason(reason) {
-  if (typeof reason !== "object" || reason === null) {
+  if (_typeof(reason) !== "object" || reason === null) {
     return reason;
   }
 
@@ -6812,8 +17674,12 @@ function wrapReason(reason) {
   }
 }
 
-class MessageHandler {
-  constructor(sourceName, targetName, comObj) {
+var MessageHandler = /*#__PURE__*/function () {
+  function MessageHandler(sourceName, targetName, comObj) {
+    var _this = this;
+
+    _classCallCheck(this, MessageHandler);
+
     this.sourceName = sourceName;
     this.targetName = targetName;
     this.comObj = comObj;
@@ -6825,28 +17691,28 @@ class MessageHandler {
     this.callbackCapabilities = Object.create(null);
     this.actionHandler = Object.create(null);
 
-    this._onComObjOnMessage = event => {
-      const data = event.data;
+    this._onComObjOnMessage = function (event) {
+      var data = event.data;
 
-      if (data.targetName !== this.sourceName) {
+      if (data.targetName !== _this.sourceName) {
         return;
       }
 
       if (data.stream) {
-        this._processStreamMessage(data);
+        _this._processStreamMessage(data);
 
         return;
       }
 
       if (data.callback) {
-        const callbackId = data.callbackId;
-        const capability = this.callbackCapabilities[callbackId];
+        var callbackId = data.callbackId;
+        var capability = _this.callbackCapabilities[callbackId];
 
         if (!capability) {
-          throw new Error(`Cannot resolve callback ${callbackId}`);
+          throw new Error("Cannot resolve callback ".concat(callbackId));
         }
 
-        delete this.callbackCapabilities[callbackId];
+        delete _this.callbackCapabilities[callbackId];
 
         if (data.callback === CallbackKind.DATA) {
           capability.resolve(data.data);
@@ -6859,15 +17725,15 @@ class MessageHandler {
         return;
       }
 
-      const action = this.actionHandler[data.action];
+      var action = _this.actionHandler[data.action];
 
       if (!action) {
-        throw new Error(`Unknown action from worker: ${data.action}`);
+        throw new Error("Unknown action from worker: ".concat(data.action));
       }
 
       if (data.callbackId) {
-        const cbSourceName = this.sourceName;
-        const cbTargetName = data.sourceName;
+        var cbSourceName = _this.sourceName;
+        var cbTargetName = data.sourceName;
         new Promise(function (resolve) {
           resolve(action(data.data));
         }).then(function (result) {
@@ -6891,7 +17757,7 @@ class MessageHandler {
       }
 
       if (data.streamId) {
-        this._createStreamSink(data);
+        _this._createStreamSink(data);
 
         return;
       }
@@ -6902,365 +17768,397 @@ class MessageHandler {
     comObj.addEventListener("message", this._onComObjOnMessage);
   }
 
-  on(actionName, handler) {
-    const ah = this.actionHandler;
+  _createClass(MessageHandler, [{
+    key: "on",
+    value: function on(actionName, handler) {
+      var ah = this.actionHandler;
 
-    if (ah[actionName]) {
-      throw new Error(`There is already an actionName called "${actionName}"`);
-    }
-
-    ah[actionName] = handler;
-  }
-
-  send(actionName, data, transfers) {
-    this._postMessage({
-      sourceName: this.sourceName,
-      targetName: this.targetName,
-      action: actionName,
-      data
-    }, transfers);
-  }
-
-  sendWithPromise(actionName, data, transfers) {
-    const callbackId = this.callbackId++;
-    const capability = (0, _util.createPromiseCapability)();
-    this.callbackCapabilities[callbackId] = capability;
+      if (ah[actionName]) {
+        throw new Error("There is already an actionName called \"".concat(actionName, "\""));
+      }
 
-    try {
+      ah[actionName] = handler;
+    }
+  }, {
+    key: "send",
+    value: function send(actionName, data, transfers) {
       this._postMessage({
         sourceName: this.sourceName,
         targetName: this.targetName,
         action: actionName,
-        callbackId,
-        data
+        data: data
       }, transfers);
-    } catch (ex) {
-      capability.reject(ex);
-    }
-
-    return capability.promise;
-  }
-
-  sendWithStream(actionName, data, queueingStrategy, transfers) {
-    const streamId = this.streamId++;
-    const sourceName = this.sourceName;
-    const targetName = this.targetName;
-    const comObj = this.comObj;
-    return new ReadableStream({
-      start: controller => {
-        const startCapability = (0, _util.createPromiseCapability)();
-        this.streamControllers[streamId] = {
-          controller,
-          startCall: startCapability,
-          pullCall: null,
-          cancelCall: null,
-          isClosed: false
-        };
+    }
+  }, {
+    key: "sendWithPromise",
+    value: function sendWithPromise(actionName, data, transfers) {
+      var callbackId = this.callbackId++;
+      var capability = (0, _util.createPromiseCapability)();
+      this.callbackCapabilities[callbackId] = capability;
 
+      try {
         this._postMessage({
-          sourceName,
-          targetName,
+          sourceName: this.sourceName,
+          targetName: this.targetName,
           action: actionName,
-          streamId,
-          data,
-          desiredSize: controller.desiredSize
+          callbackId: callbackId,
+          data: data
         }, transfers);
+      } catch (ex) {
+        capability.reject(ex);
+      }
+
+      return capability.promise;
+    }
+  }, {
+    key: "sendWithStream",
+    value: function sendWithStream(actionName, data, queueingStrategy, transfers) {
+      var _this2 = this;
+
+      var streamId = this.streamId++;
+      var sourceName = this.sourceName;
+      var targetName = this.targetName;
+      var comObj = this.comObj;
+      return new ReadableStream({
+        start: function start(controller) {
+          var startCapability = (0, _util.createPromiseCapability)();
+          _this2.streamControllers[streamId] = {
+            controller: controller,
+            startCall: startCapability,
+            pullCall: null,
+            cancelCall: null,
+            isClosed: false
+          };
 
-        return startCapability.promise;
-      },
-      pull: controller => {
-        const pullCapability = (0, _util.createPromiseCapability)();
-        this.streamControllers[streamId].pullCall = pullCapability;
-        comObj.postMessage({
-          sourceName,
-          targetName,
-          stream: StreamKind.PULL,
-          streamId,
-          desiredSize: controller.desiredSize
-        });
-        return pullCapability.promise;
-      },
-      cancel: reason => {
-        (0, _util.assert)(reason instanceof Error, "cancel must have a valid reason");
-        const cancelCapability = (0, _util.createPromiseCapability)();
-        this.streamControllers[streamId].cancelCall = cancelCapability;
-        this.streamControllers[streamId].isClosed = true;
-        comObj.postMessage({
-          sourceName,
-          targetName,
-          stream: StreamKind.CANCEL,
-          streamId,
-          reason: wrapReason(reason)
-        });
-        return cancelCapability.promise;
-      }
-    }, queueingStrategy);
-  }
-
-  _createStreamSink(data) {
-    const self = this;
-    const action = this.actionHandler[data.action];
-    const streamId = data.streamId;
-    const sourceName = this.sourceName;
-    const targetName = data.sourceName;
-    const comObj = this.comObj;
-    const streamSink = {
-      enqueue(chunk, size = 1, transfers) {
-        if (this.isCancelled) {
-          return;
+          _this2._postMessage({
+            sourceName: sourceName,
+            targetName: targetName,
+            action: actionName,
+            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;
+          comObj.postMessage({
+            sourceName: sourceName,
+            targetName: targetName,
+            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;
+          comObj.postMessage({
+            sourceName: sourceName,
+            targetName: targetName,
+            stream: StreamKind.CANCEL,
+            streamId: streamId,
+            reason: wrapReason(reason)
+          });
+          return cancelCapability.promise;
         }
+      }, queueingStrategy);
+    }
+  }, {
+    key: "_createStreamSink",
+    value: function _createStreamSink(data) {
+      var self = this;
+      var action = this.actionHandler[data.action];
+      var streamId = data.streamId;
+      var sourceName = this.sourceName;
+      var targetName = data.sourceName;
+      var comObj = this.comObj;
+      var streamSink = {
+        enqueue: function enqueue(chunk) {
+          var size = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : 1;
+          var transfers = arguments.length > 2 ? arguments[2] : undefined;
+
+          if (this.isCancelled) {
+            return;
+          }
 
-        const lastDesiredSize = this.desiredSize;
-        this.desiredSize -= size;
+          var lastDesiredSize = this.desiredSize;
+          this.desiredSize -= size;
 
-        if (lastDesiredSize > 0 && this.desiredSize <= 0) {
-          this.sinkCapability = (0, _util.createPromiseCapability)();
-          this.ready = this.sinkCapability.promise;
-        }
+          if (lastDesiredSize > 0 && this.desiredSize <= 0) {
+            this.sinkCapability = (0, _util.createPromiseCapability)();
+            this.ready = this.sinkCapability.promise;
+          }
 
-        self._postMessage({
-          sourceName,
-          targetName,
-          stream: StreamKind.ENQUEUE,
-          streamId,
-          chunk
-        }, transfers);
-      },
+          self._postMessage({
+            sourceName: sourceName,
+            targetName: targetName,
+            stream: StreamKind.ENQUEUE,
+            streamId: streamId,
+            chunk: chunk
+          }, transfers);
+        },
+        close: function close() {
+          if (this.isCancelled) {
+            return;
+          }
 
-      close() {
-        if (this.isCancelled) {
-          return;
-        }
+          this.isCancelled = true;
+          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");
 
-        this.isCancelled = true;
+          if (this.isCancelled) {
+            return;
+          }
+
+          this.isCancelled = true;
+          comObj.postMessage({
+            sourceName: sourceName,
+            targetName: targetName,
+            stream: StreamKind.ERROR,
+            streamId: streamId,
+            reason: wrapReason(reason)
+          });
+        },
+        sinkCapability: (0, _util.createPromiseCapability)(),
+        onPull: null,
+        onCancel: null,
+        isCancelled: false,
+        desiredSize: data.desiredSize,
+        ready: null
+      };
+      streamSink.sinkCapability.resolve();
+      streamSink.ready = streamSink.sinkCapability.promise;
+      this.streamSinks[streamId] = streamSink;
+      new Promise(function (resolve) {
+        resolve(action(data.data, streamSink));
+      }).then(function () {
         comObj.postMessage({
-          sourceName,
-          targetName,
-          stream: StreamKind.CLOSE,
-          streamId
+          sourceName: sourceName,
+          targetName: targetName,
+          stream: StreamKind.START_COMPLETE,
+          streamId: streamId,
+          success: true
         });
-        delete self.streamSinks[streamId];
-      },
-
-      error(reason) {
-        (0, _util.assert)(reason instanceof Error, "error must have a valid reason");
-
-        if (this.isCancelled) {
-          return;
-        }
-
-        this.isCancelled = true;
+      }, function (reason) {
         comObj.postMessage({
-          sourceName,
-          targetName,
-          stream: StreamKind.ERROR,
-          streamId,
+          sourceName: sourceName,
+          targetName: targetName,
+          stream: StreamKind.START_COMPLETE,
+          streamId: streamId,
           reason: wrapReason(reason)
         });
-      },
-
-      sinkCapability: (0, _util.createPromiseCapability)(),
-      onPull: null,
-      onCancel: null,
-      isCancelled: false,
-      desiredSize: data.desiredSize,
-      ready: null
-    };
-    streamSink.sinkCapability.resolve();
-    streamSink.ready = streamSink.sinkCapability.promise;
-    this.streamSinks[streamId] = streamSink;
-    new Promise(function (resolve) {
-      resolve(action(data.data, streamSink));
-    }).then(function () {
-      comObj.postMessage({
-        sourceName,
-        targetName,
-        stream: StreamKind.START_COMPLETE,
-        streamId,
-        success: true
       });
-    }, function (reason) {
-      comObj.postMessage({
-        sourceName,
-        targetName,
-        stream: StreamKind.START_COMPLETE,
-        streamId,
-        reason: wrapReason(reason)
-      });
-    });
-  }
+    }
+  }, {
+    key: "_processStreamMessage",
+    value: function _processStreamMessage(data) {
+      var streamId = data.streamId;
+      var sourceName = this.sourceName;
+      var targetName = data.sourceName;
+      var comObj = this.comObj;
+
+      switch (data.stream) {
+        case StreamKind.START_COMPLETE:
+          if (data.success) {
+            this.streamControllers[streamId].startCall.resolve();
+          } else {
+            this.streamControllers[streamId].startCall.reject(wrapReason(data.reason));
+          }
 
-  _processStreamMessage(data) {
-    const streamId = data.streamId;
-    const sourceName = this.sourceName;
-    const targetName = data.sourceName;
-    const comObj = this.comObj;
+          break;
 
-    switch (data.stream) {
-      case StreamKind.START_COMPLETE:
-        if (data.success) {
-          this.streamControllers[streamId].startCall.resolve();
-        } else {
-          this.streamControllers[streamId].startCall.reject(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;
+          break;
 
-      case StreamKind.PULL_COMPLETE:
-        if (data.success) {
-          this.streamControllers[streamId].pullCall.resolve();
-        } else {
-          this.streamControllers[streamId].pullCall.reject(wrapReason(data.reason));
-        }
+        case StreamKind.PULL:
+          if (!this.streamSinks[streamId]) {
+            comObj.postMessage({
+              sourceName: sourceName,
+              targetName: targetName,
+              stream: StreamKind.PULL_COMPLETE,
+              streamId: streamId,
+              success: true
+            });
+            break;
+          }
 
-        break;
+          if (this.streamSinks[streamId].desiredSize <= 0 && data.desiredSize > 0) {
+            this.streamSinks[streamId].sinkCapability.resolve();
+          }
 
-      case StreamKind.PULL:
-        if (!this.streamSinks[streamId]) {
-          comObj.postMessage({
-            sourceName,
-            targetName,
-            stream: StreamKind.PULL_COMPLETE,
-            streamId,
-            success: true
+          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) {
+            comObj.postMessage({
+              sourceName: sourceName,
+              targetName: targetName,
+              stream: StreamKind.PULL_COMPLETE,
+              streamId: streamId,
+              reason: wrapReason(reason)
+            });
           });
           break;
-        }
 
-        if (this.streamSinks[streamId].desiredSize <= 0 && data.desiredSize > 0) {
-          this.streamSinks[streamId].sinkCapability.resolve();
-        }
+        case StreamKind.ENQUEUE:
+          (0, _util.assert)(this.streamControllers[streamId], "enqueue should have stream controller");
 
-        this.streamSinks[streamId].desiredSize = data.desiredSize;
-        const {
-          onPull
-        } = this.streamSinks[data.streamId];
-        new Promise(function (resolve) {
-          resolve(onPull && onPull());
-        }).then(function () {
-          comObj.postMessage({
-            sourceName,
-            targetName,
-            stream: StreamKind.PULL_COMPLETE,
-            streamId,
-            success: true
-          });
-        }, function (reason) {
-          comObj.postMessage({
-            sourceName,
-            targetName,
-            stream: StreamKind.PULL_COMPLETE,
-            streamId,
-            reason: wrapReason(reason)
-          });
-        });
-        break;
-
-      case StreamKind.ENQUEUE:
-        (0, _util.assert)(this.streamControllers[streamId], "enqueue should have stream controller");
+          if (this.streamControllers[streamId].isClosed) {
+            break;
+          }
 
-        if (this.streamControllers[streamId].isClosed) {
+          this.streamControllers[streamId].controller.enqueue(data.chunk);
           break;
-        }
-
-        this.streamControllers[streamId].controller.enqueue(data.chunk);
-        break;
 
-      case StreamKind.CLOSE:
-        (0, _util.assert)(this.streamControllers[streamId], "close should have stream controller");
+        case StreamKind.CLOSE:
+          (0, _util.assert)(this.streamControllers[streamId], "close should have stream controller");
 
-        if (this.streamControllers[streamId].isClosed) {
-          break;
-        }
-
-        this.streamControllers[streamId].isClosed = true;
-        this.streamControllers[streamId].controller.close();
+          if (this.streamControllers[streamId].isClosed) {
+            break;
+          }
 
-        this._deleteStreamController(streamId);
+          this.streamControllers[streamId].isClosed = true;
+          this.streamControllers[streamId].controller.close();
 
-        break;
+          this._deleteStreamController(streamId);
 
-      case StreamKind.ERROR:
-        (0, _util.assert)(this.streamControllers[streamId], "error should have stream controller");
-        this.streamControllers[streamId].controller.error(wrapReason(data.reason));
+          break;
 
-        this._deleteStreamController(streamId);
+        case StreamKind.ERROR:
+          (0, _util.assert)(this.streamControllers[streamId], "error should have stream controller");
+          this.streamControllers[streamId].controller.error(wrapReason(data.reason));
 
-        break;
+          this._deleteStreamController(streamId);
 
-      case StreamKind.CANCEL_COMPLETE:
-        if (data.success) {
-          this.streamControllers[streamId].cancelCall.resolve();
-        } else {
-          this.streamControllers[streamId].cancelCall.reject(wrapReason(data.reason));
-        }
+          break;
 
-        this._deleteStreamController(streamId);
+        case StreamKind.CANCEL_COMPLETE:
+          if (data.success) {
+            this.streamControllers[streamId].cancelCall.resolve();
+          } else {
+            this.streamControllers[streamId].cancelCall.reject(wrapReason(data.reason));
+          }
 
-        break;
+          this._deleteStreamController(streamId);
 
-      case StreamKind.CANCEL:
-        if (!this.streamSinks[streamId]) {
           break;
-        }
 
-        const {
-          onCancel
-        } = this.streamSinks[data.streamId];
-        new Promise(function (resolve) {
-          resolve(onCancel && onCancel(wrapReason(data.reason)));
-        }).then(function () {
-          comObj.postMessage({
-            sourceName,
-            targetName,
-            stream: StreamKind.CANCEL_COMPLETE,
-            streamId,
-            success: true
-          });
-        }, function (reason) {
-          comObj.postMessage({
-            sourceName,
-            targetName,
-            stream: StreamKind.CANCEL_COMPLETE,
-            streamId,
-            reason: wrapReason(reason)
+        case StreamKind.CANCEL:
+          if (!this.streamSinks[streamId]) {
+            break;
+          }
+
+          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) {
+            comObj.postMessage({
+              sourceName: sourceName,
+              targetName: targetName,
+              stream: StreamKind.CANCEL_COMPLETE,
+              streamId: streamId,
+              reason: wrapReason(reason)
+            });
           });
-        });
-        this.streamSinks[streamId].sinkCapability.reject(wrapReason(data.reason));
-        this.streamSinks[streamId].isCancelled = true;
-        delete this.streamSinks[streamId];
-        break;
+          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");
-    }
-  }
+        default:
+          throw new Error("Unexpected stream case");
+      }
+    }
+  }, {
+    key: "_deleteStreamController",
+    value: function () {
+      var _deleteStreamController2 = _asyncToGenerator( /*#__PURE__*/_regenerator["default"].mark(function _callee(streamId) {
+        return _regenerator["default"].wrap(function _callee$(_context) {
+          while (1) {
+            switch (_context.prev = _context.next) {
+              case 0:
+                _context.next = 2;
+                return Promise.allSettled([this.streamControllers[streamId].startCall, this.streamControllers[streamId].pullCall, this.streamControllers[streamId].cancelCall].map(function (capability) {
+                  return capability && capability.promise;
+                }));
+
+              case 2:
+                delete this.streamControllers[streamId];
+
+              case 3:
+              case "end":
+                return _context.stop();
+            }
+          }
+        }, _callee, this);
+      }));
 
-  async _deleteStreamController(streamId) {
-    await Promise.allSettled([this.streamControllers[streamId].startCall, this.streamControllers[streamId].pullCall, this.streamControllers[streamId].cancelCall].map(function (capability) {
-      return capability && capability.promise;
-    }));
-    delete this.streamControllers[streamId];
-  }
+      function _deleteStreamController(_x) {
+        return _deleteStreamController2.apply(this, arguments);
+      }
 
-  _postMessage(message, transfers) {
-    if (transfers && this.postMessageTransfers) {
-      this.comObj.postMessage(message, transfers);
-    } else {
-      this.comObj.postMessage(message);
+      return _deleteStreamController;
+    }()
+  }, {
+    key: "_postMessage",
+    value: function _postMessage(message, transfers) {
+      if (transfers && this.postMessageTransfers) {
+        this.comObj.postMessage(message, transfers);
+      } else {
+        this.comObj.postMessage(message);
+      }
     }
-  }
-
-  destroy() {
-    this.comObj.removeEventListener("message", this._onComObjOnMessage);
-  }
+  }, {
+    key: "destroy",
+    value: function destroy() {
+      this.comObj.removeEventListener("message", this._onComObjOnMessage);
+    }
+  }]);
 
-}
+  return MessageHandler;
+}();
 
 exports.MessageHandler = MessageHandler;
 
 /***/ }),
-/* 12 */
+/* 205 */
 /***/ (function(module, exports, __w_pdfjs_require__) {
 
 "use strict";
@@ -7271,16 +18169,38 @@ Object.defineProperty(exports, "__esModule", {
 });
 exports.Metadata = void 0;
 
-var _util = __w_pdfjs_require__(2);
+var _util = __w_pdfjs_require__(5);
+
+var _xml_parser = __w_pdfjs_require__(206);
+
+function _slicedToArray(arr, i) { return _arrayWithHoles(arr) || _iterableToArrayLimit(arr, i) || _unsupportedIterableToArray(arr, i) || _nonIterableRest(); }
+
+function _nonIterableRest() { throw new TypeError("Invalid attempt to destructure non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method."); }
+
+function _iterableToArrayLimit(arr, i) { if (typeof Symbol === "undefined" || !(Symbol.iterator in Object(arr))) return; var _arr = []; var _n = true; var _d = false; var _e = undefined; try { for (var _i = arr[Symbol.iterator](), _s; !(_n = (_s = _i.next()).done); _n = true) { _arr.push(_s.value); if (i && _arr.length === i) break; } } catch (err) { _d = true; _e = err; } finally { try { if (!_n && _i["return"] != null) _i["return"](); } finally { if (_d) throw _e; } } return _arr; }
+
+function _arrayWithHoles(arr) { if (Array.isArray(arr)) return arr; }
+
+function _createForOfIteratorHelper(o, allowArrayLike) { var it; if (typeof Symbol === "undefined" || o[Symbol.iterator] == null) { if (Array.isArray(o) || (it = _unsupportedIterableToArray(o)) || allowArrayLike && o && typeof o.length === "number") { if (it) o = it; var i = 0; var F = function F() {}; return { s: F, n: function n() { if (i >= o.length) return { done: true }; return { done: false, value: o[i++] }; }, e: function e(_e2) { throw _e2; }, f: F }; } throw new TypeError("Invalid attempt to iterate non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method."); } var normalCompletion = true, didErr = false, err; return { s: function s() { it = o[Symbol.iterator](); }, n: function n() { var step = it.next(); normalCompletion = step.done; return step; }, e: function e(_e3) { didErr = true; err = _e3; }, f: function f() { try { if (!normalCompletion && it["return"] != null) it["return"](); } finally { if (didErr) throw err; } } }; }
+
+function _unsupportedIterableToArray(o, minLen) { if (!o) return; if (typeof o === "string") return _arrayLikeToArray(o, minLen); var n = Object.prototype.toString.call(o).slice(8, -1); if (n === "Object" && o.constructor) n = o.constructor.name; if (n === "Map" || n === "Set") return Array.from(o); if (n === "Arguments" || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(n)) return _arrayLikeToArray(o, minLen); }
+
+function _arrayLikeToArray(arr, len) { if (len == null || len > arr.length) len = arr.length; for (var i = 0, arr2 = new Array(len); i < len; i++) { arr2[i] = arr[i]; } return arr2; }
 
-var _xml_parser = __w_pdfjs_require__(13);
+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 Metadata = /*#__PURE__*/function () {
+  function Metadata(data) {
+    _classCallCheck(this, Metadata);
 
-class Metadata {
-  constructor(data) {
     (0, _util.assert)(typeof data === "string", "Metadata: input is not a string");
     data = this._repair(data);
-    const parser = new _xml_parser.SimpleXMLParser();
-    const xmlDocument = parser.parseFromString(data);
+    var parser = new _xml_parser.SimpleXMLParser();
+    var xmlDocument = parser.parseFromString(data);
     this._metadataMap = new Map();
 
     if (xmlDocument) {
@@ -7288,107 +18208,128 @@ class Metadata {
     }
   }
 
-  _repair(data) {
-    return data.replace(/^[^<]+/, "").replace(/>\\376\\377([^<]+)/g, function (all, codes) {
-      const bytes = codes.replace(/\\([0-3])([0-7])([0-7])/g, function (code, d1, d2, d3) {
-        return String.fromCharCode(d1 * 64 + d2 * 8 + d3 * 1);
-      }).replace(/&(amp|apos|gt|lt|quot);/g, function (str, name) {
-        switch (name) {
-          case "amp":
-            return "&";
+  _createClass(Metadata, [{
+    key: "_repair",
+    value: function _repair(data) {
+      return data.replace(/^[^<]+/, "").replace(/>\\376\\377([^<]+)/g, function (all, codes) {
+        var bytes = codes.replace(/\\([0-3])([0-7])([0-7])/g, function (code, d1, d2, d3) {
+          return String.fromCharCode(d1 * 64 + d2 * 8 + d3 * 1);
+        }).replace(/&(amp|apos|gt|lt|quot);/g, function (str, name) {
+          switch (name) {
+            case "amp":
+              return "&";
 
-          case "apos":
-            return "'";
+            case "apos":
+              return "'";
 
-          case "gt":
-            return ">";
+            case "gt":
+              return ">";
 
-          case "lt":
-            return "<";
+            case "lt":
+              return "<";
 
-          case "quot":
-            return '"';
-        }
+            case "quot":
+              return '"';
+          }
 
-        throw new Error(`_repair: ${name} isn't defined.`);
-      });
-      let chars = "";
+          throw new Error("_repair: ".concat(name, " isn't defined."));
+        });
+        var chars = "";
 
-      for (let i = 0, ii = bytes.length; i < ii; i += 2) {
-        const code = bytes.charCodeAt(i) * 256 + bytes.charCodeAt(i + 1);
+        for (var i = 0, ii = bytes.length; i < ii; i += 2) {
+          var code = bytes.charCodeAt(i) * 256 + bytes.charCodeAt(i + 1);
 
-        if (code >= 32 && code < 127 && code !== 60 && code !== 62 && code !== 38) {
-          chars += String.fromCharCode(code);
-        } else {
-          chars += "&#x" + (0x10000 + code).toString(16).substring(1) + ";";
+          if (code >= 32 && code < 127 && code !== 60 && code !== 62 && code !== 38) {
+            chars += String.fromCharCode(code);
+          } else {
+            chars += "&#x" + (0x10000 + code).toString(16).substring(1) + ";";
+          }
         }
-      }
 
-      return ">" + chars;
-    });
-  }
-
-  _parse(xmlDocument) {
-    let rdf = xmlDocument.documentElement;
+        return ">" + chars;
+      });
+    }
+  }, {
+    key: "_parse",
+    value: function _parse(xmlDocument) {
+      var rdf = xmlDocument.documentElement;
 
-    if (rdf.nodeName.toLowerCase() !== "rdf:rdf") {
-      rdf = rdf.firstChild;
+      if (rdf.nodeName.toLowerCase() !== "rdf:rdf") {
+        rdf = rdf.firstChild;
 
-      while (rdf && rdf.nodeName.toLowerCase() !== "rdf:rdf") {
-        rdf = rdf.nextSibling;
+        while (rdf && rdf.nodeName.toLowerCase() !== "rdf:rdf") {
+          rdf = rdf.nextSibling;
+        }
       }
-    }
 
-    const nodeName = rdf ? rdf.nodeName.toLowerCase() : null;
+      var nodeName = rdf ? rdf.nodeName.toLowerCase() : null;
 
-    if (!rdf || nodeName !== "rdf:rdf" || !rdf.hasChildNodes()) {
-      return;
-    }
+      if (!rdf || nodeName !== "rdf:rdf" || !rdf.hasChildNodes()) {
+        return;
+      }
 
-    const children = rdf.childNodes;
+      var children = rdf.childNodes;
 
-    for (let i = 0, ii = children.length; i < ii; i++) {
-      const desc = children[i];
+      for (var i = 0, ii = children.length; i < ii; i++) {
+        var desc = children[i];
 
-      if (desc.nodeName.toLowerCase() !== "rdf:description") {
-        continue;
-      }
+        if (desc.nodeName.toLowerCase() !== "rdf:description") {
+          continue;
+        }
 
-      for (let j = 0, jj = desc.childNodes.length; j < jj; j++) {
-        if (desc.childNodes[j].nodeName.toLowerCase() !== "#text") {
-          const entry = desc.childNodes[j];
-          const name = entry.nodeName.toLowerCase();
+        for (var j = 0, jj = desc.childNodes.length; j < jj; j++) {
+          if (desc.childNodes[j].nodeName.toLowerCase() !== "#text") {
+            var entry = desc.childNodes[j];
+            var name = entry.nodeName.toLowerCase();
 
-          this._metadataMap.set(name, entry.textContent.trim());
+            this._metadataMap.set(name, entry.textContent.trim());
+          }
         }
       }
     }
-  }
-
-  get(name) {
-    return this._metadataMap.has(name) ? this._metadataMap.get(name) : null;
-  }
+  }, {
+    key: "get",
+    value: function get(name) {
+      return this._metadataMap.has(name) ? this._metadataMap.get(name) : null;
+    }
+  }, {
+    key: "getAll",
+    value: function getAll() {
+      var obj = Object.create(null);
 
-  getAll() {
-    const obj = Object.create(null);
+      var _iterator = _createForOfIteratorHelper(this._metadataMap),
+          _step;
 
-    for (const [key, value] of this._metadataMap) {
-      obj[key] = value;
-    }
+      try {
+        for (_iterator.s(); !(_step = _iterator.n()).done;) {
+          var _step$value = _slicedToArray(_step.value, 2),
+              key = _step$value[0],
+              value = _step$value[1];
 
-    return obj;
-  }
+          obj[key] = value;
+        }
+      } catch (err) {
+        _iterator.e(err);
+      } finally {
+        _iterator.f();
+      }
 
-  has(name) {
-    return this._metadataMap.has(name);
-  }
+      return obj;
+    }
+  }, {
+    key: "has",
+    value: function has(name) {
+      return this._metadataMap.has(name);
+    }
+  }]);
 
-}
+  return Metadata;
+}();
 
 exports.Metadata = Metadata;
 
 /***/ }),
-/* 13 */
+/* 206 */
 /***/ (function(module, exports, __w_pdfjs_require__) {
 
 "use strict";
@@ -7398,7 +18339,46 @@ Object.defineProperty(exports, "__esModule", {
   value: true
 });
 exports.SimpleXMLParser = void 0;
-const XMLParserErrorCode = {
+
+function _typeof(obj) { "@babel/helpers - typeof"; 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 _slicedToArray(arr, i) { return _arrayWithHoles(arr) || _iterableToArrayLimit(arr, i) || _unsupportedIterableToArray(arr, i) || _nonIterableRest(); }
+
+function _nonIterableRest() { throw new TypeError("Invalid attempt to destructure non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method."); }
+
+function _unsupportedIterableToArray(o, minLen) { if (!o) return; if (typeof o === "string") return _arrayLikeToArray(o, minLen); var n = Object.prototype.toString.call(o).slice(8, -1); if (n === "Object" && o.constructor) n = o.constructor.name; if (n === "Map" || n === "Set") return Array.from(o); if (n === "Arguments" || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(n)) return _arrayLikeToArray(o, minLen); }
+
+function _arrayLikeToArray(arr, len) { if (len == null || len > arr.length) len = arr.length; for (var i = 0, arr2 = new Array(len); i < len; i++) { arr2[i] = arr[i]; } return arr2; }
+
+function _iterableToArrayLimit(arr, i) { if (typeof Symbol === "undefined" || !(Symbol.iterator in Object(arr))) return; var _arr = []; var _n = true; var _d = false; var _e = undefined; try { for (var _i = arr[Symbol.iterator](), _s; !(_n = (_s = _i.next()).done); _n = true) { _arr.push(_s.value); if (i && _arr.length === i) break; } } catch (err) { _d = true; _e = err; } finally { try { if (!_n && _i["return"] != null) _i["return"](); } finally { if (_d) throw _e; } } return _arr; }
+
+function _arrayWithHoles(arr) { if (Array.isArray(arr)) return arr; }
+
+function _get(target, property, receiver) { if (typeof Reflect !== "undefined" && Reflect.get) { _get = Reflect.get; } else { _get = function _get(target, property, receiver) { var base = _superPropBase(target, property); if (!base) return; var desc = Object.getOwnPropertyDescriptor(base, property); if (desc.get) { return desc.get.call(receiver); } return desc.value; }; } return _get(target, property, receiver || target); }
+
+function _superPropBase(object, property) { while (!Object.prototype.hasOwnProperty.call(object, property)) { object = _getPrototypeOf(object); if (object === null) break; } return object; }
+
+function _inherits(subClass, superClass) { if (typeof superClass !== "function" && superClass !== null) { throw new TypeError("Super expression must either be null or a function"); } subClass.prototype = Object.create(superClass && superClass.prototype, { constructor: { value: subClass, writable: true, configurable: true } }); if (superClass) _setPrototypeOf(subClass, superClass); }
+
+function _setPrototypeOf(o, p) { _setPrototypeOf = Object.setPrototypeOf || function _setPrototypeOf(o, p) { o.__proto__ = p; return o; }; return _setPrototypeOf(o, p); }
+
+function _createSuper(Derived) { var hasNativeReflectConstruct = _isNativeReflectConstruct(); return function _createSuperInternal() { var Super = _getPrototypeOf(Derived), result; if (hasNativeReflectConstruct) { var NewTarget = _getPrototypeOf(this).constructor; result = Reflect.construct(Super, arguments, NewTarget); } else { result = Super.apply(this, arguments); } return _possibleConstructorReturn(this, result); }; }
+
+function _possibleConstructorReturn(self, call) { if (call && (_typeof(call) === "object" || typeof call === "function")) { return call; } return _assertThisInitialized(self); }
+
+function _assertThisInitialized(self) { if (self === void 0) { throw new ReferenceError("this hasn't been initialised - super() hasn't been called"); } return self; }
+
+function _isNativeReflectConstruct() { if (typeof Reflect === "undefined" || !Reflect.construct) return false; if (Reflect.construct.sham) return false; if (typeof Proxy === "function") return true; try { Date.prototype.toString.call(Reflect.construct(Date, [], function () {})); return true; } catch (e) { return false; } }
+
+function _getPrototypeOf(o) { _getPrototypeOf = Object.setPrototypeOf ? Object.getPrototypeOf : function _getPrototypeOf(o) { return o.__proto__ || Object.getPrototypeOf(o); }; return _getPrototypeOf(o); }
+
+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 XMLParserErrorCode = {
   NoError: 0,
   EndOfDocument: -1,
   UnterminatedCdat: -2,
@@ -7413,12 +18393,12 @@ const XMLParserErrorCode = {
 };
 
 function isWhitespace(s, index) {
-  const ch = s[index];
+  var ch = s[index];
   return ch === " " || ch === "\n" || ch === "\r" || ch === "\t";
 }
 
 function isWhitespaceString(s) {
-  for (let i = 0, ii = s.length; i < ii; i++) {
+  for (var i = 0, ii = s.length; i < ii; i++) {
     if (!isWhitespace(s, i)) {
       return false;
     }
@@ -7427,275 +18407,299 @@ function isWhitespaceString(s) {
   return true;
 }
 
-class XMLParserBase {
-  _resolveEntities(s) {
-    return s.replace(/&([^;]+);/g, (all, entity) => {
-      if (entity.substring(0, 2) === "#x") {
-        return String.fromCharCode(parseInt(entity.substring(2), 16));
-      } else if (entity.substring(0, 1) === "#") {
-        return String.fromCharCode(parseInt(entity.substring(1), 10));
-      }
-
-      switch (entity) {
-        case "lt":
-          return "<";
+var XMLParserBase = /*#__PURE__*/function () {
+  function XMLParserBase() {
+    _classCallCheck(this, XMLParserBase);
+  }
 
-        case "gt":
-          return ">";
+  _createClass(XMLParserBase, [{
+    key: "_resolveEntities",
+    value: function _resolveEntities(s) {
+      var _this = this;
 
-        case "amp":
-          return "&";
+      return s.replace(/&([^;]+);/g, function (all, entity) {
+        if (entity.substring(0, 2) === "#x") {
+          return String.fromCharCode(parseInt(entity.substring(2), 16));
+        } else if (entity.substring(0, 1) === "#") {
+          return String.fromCharCode(parseInt(entity.substring(1), 10));
+        }
 
-        case "quot":
-          return '"';
-      }
+        switch (entity) {
+          case "lt":
+            return "<";
 
-      return this.onResolveEntity(entity);
-    });
-  }
+          case "gt":
+            return ">";
 
-  _parseContent(s, start) {
-    const attributes = [];
-    let pos = start;
+          case "amp":
+            return "&";
 
-    function skipWs() {
-      while (pos < s.length && isWhitespace(s, pos)) {
-        ++pos;
-      }
-    }
+          case "quot":
+            return '"';
+        }
 
-    while (pos < s.length && !isWhitespace(s, pos) && s[pos] !== ">" && s[pos] !== "/") {
-      ++pos;
+        return _this.onResolveEntity(entity);
+      });
     }
+  }, {
+    key: "_parseContent",
+    value: function _parseContent(s, start) {
+      var attributes = [];
+      var pos = start;
 
-    const name = s.substring(start, pos);
-    skipWs();
-
-    while (pos < s.length && s[pos] !== ">" && s[pos] !== "/" && s[pos] !== "?") {
-      skipWs();
-      let attrName = "",
-          attrValue = "";
+      function skipWs() {
+        while (pos < s.length && isWhitespace(s, pos)) {
+          ++pos;
+        }
+      }
 
-      while (pos < s.length && !isWhitespace(s, pos) && s[pos] !== "=") {
-        attrName += s[pos];
+      while (pos < s.length && !isWhitespace(s, pos) && s[pos] !== ">" && s[pos] !== "/") {
         ++pos;
       }
 
+      var name = s.substring(start, pos);
       skipWs();
 
-      if (s[pos] !== "=") {
-        return null;
-      }
+      while (pos < s.length && s[pos] !== ">" && s[pos] !== "/" && s[pos] !== "?") {
+        skipWs();
+        var attrName = "",
+            attrValue = "";
 
-      ++pos;
-      skipWs();
-      const attrEndChar = s[pos];
+        while (pos < s.length && !isWhitespace(s, pos) && s[pos] !== "=") {
+          attrName += s[pos];
+          ++pos;
+        }
 
-      if (attrEndChar !== '"' && attrEndChar !== "'") {
-        return null;
-      }
+        skipWs();
 
-      const attrEndIndex = s.indexOf(attrEndChar, ++pos);
+        if (s[pos] !== "=") {
+          return null;
+        }
 
-      if (attrEndIndex < 0) {
-        return null;
-      }
+        ++pos;
+        skipWs();
+        var attrEndChar = s[pos];
 
-      attrValue = s.substring(pos, attrEndIndex);
-      attributes.push({
-        name: attrName,
-        value: this._resolveEntities(attrValue)
-      });
-      pos = attrEndIndex + 1;
-      skipWs();
-    }
+        if (attrEndChar !== '"' && attrEndChar !== "'") {
+          return null;
+        }
 
-    return {
-      name,
-      attributes,
-      parsed: pos - start
-    };
-  }
+        var attrEndIndex = s.indexOf(attrEndChar, ++pos);
 
-  _parseProcessingInstruction(s, start) {
-    let pos = start;
+        if (attrEndIndex < 0) {
+          return null;
+        }
 
-    function skipWs() {
-      while (pos < s.length && isWhitespace(s, pos)) {
-        ++pos;
+        attrValue = s.substring(pos, attrEndIndex);
+        attributes.push({
+          name: attrName,
+          value: this._resolveEntities(attrValue)
+        });
+        pos = attrEndIndex + 1;
+        skipWs();
       }
-    }
-
-    while (pos < s.length && !isWhitespace(s, pos) && s[pos] !== ">" && s[pos] !== "/") {
-      ++pos;
-    }
-
-    const name = s.substring(start, pos);
-    skipWs();
-    const attrStart = pos;
 
-    while (pos < s.length && (s[pos] !== "?" || s[pos + 1] !== ">")) {
-      ++pos;
+      return {
+        name: name,
+        attributes: attributes,
+        parsed: pos - start
+      };
     }
+  }, {
+    key: "_parseProcessingInstruction",
+    value: function _parseProcessingInstruction(s, start) {
+      var pos = start;
 
-    const value = s.substring(attrStart, pos);
-    return {
-      name,
-      value,
-      parsed: pos - start
-    };
-  }
-
-  parseXml(s) {
-    let i = 0;
-
-    while (i < s.length) {
-      const ch = s[i];
-      let j = i;
-
-      if (ch === "<") {
-        ++j;
-        const ch2 = s[j];
-        let q;
-
-        switch (ch2) {
-          case "/":
-            ++j;
-            q = s.indexOf(">", j);
+      function skipWs() {
+        while (pos < s.length && isWhitespace(s, pos)) {
+          ++pos;
+        }
+      }
 
-            if (q < 0) {
-              this.onError(XMLParserErrorCode.UnterminatedElement);
-              return;
-            }
+      while (pos < s.length && !isWhitespace(s, pos) && s[pos] !== ">" && s[pos] !== "/") {
+        ++pos;
+      }
 
-            this.onEndElement(s.substring(j, q));
-            j = q + 1;
-            break;
+      var name = s.substring(start, pos);
+      skipWs();
+      var attrStart = pos;
 
-          case "?":
-            ++j;
+      while (pos < s.length && (s[pos] !== "?" || s[pos + 1] !== ">")) {
+        ++pos;
+      }
 
-            const pi = this._parseProcessingInstruction(s, j);
+      var value = s.substring(attrStart, pos);
+      return {
+        name: name,
+        value: value,
+        parsed: pos - start
+      };
+    }
+  }, {
+    key: "parseXml",
+    value: function parseXml(s) {
+      var i = 0;
 
-            if (s.substring(j + pi.parsed, j + pi.parsed + 2) !== "?>") {
-              this.onError(XMLParserErrorCode.UnterminatedXmlDeclaration);
-              return;
-            }
+      while (i < s.length) {
+        var ch = s[i];
+        var j = i;
 
-            this.onPi(pi.name, pi.value);
-            j += pi.parsed + 2;
-            break;
+        if (ch === "<") {
+          ++j;
+          var ch2 = s[j];
+          var q = void 0;
 
-          case "!":
-            if (s.substring(j + 1, j + 3) === "--") {
-              q = s.indexOf("-->", j + 3);
+          switch (ch2) {
+            case "/":
+              ++j;
+              q = s.indexOf(">", j);
 
               if (q < 0) {
-                this.onError(XMLParserErrorCode.UnterminatedComment);
+                this.onError(XMLParserErrorCode.UnterminatedElement);
                 return;
               }
 
-              this.onComment(s.substring(j + 3, q));
-              j = q + 3;
-            } else if (s.substring(j + 1, j + 8) === "[CDATA[") {
-              q = s.indexOf("]]>", j + 8);
+              this.onEndElement(s.substring(j, q));
+              j = q + 1;
+              break;
 
-              if (q < 0) {
-                this.onError(XMLParserErrorCode.UnterminatedCdat);
-                return;
-              }
+            case "?":
+              ++j;
 
-              this.onCdata(s.substring(j + 8, q));
-              j = q + 3;
-            } else if (s.substring(j + 1, j + 8) === "DOCTYPE") {
-              const q2 = s.indexOf("[", j + 8);
-              let complexDoctype = false;
-              q = s.indexOf(">", j + 8);
+              var pi = this._parseProcessingInstruction(s, j);
 
-              if (q < 0) {
-                this.onError(XMLParserErrorCode.UnterminatedDoctypeDeclaration);
+              if (s.substring(j + pi.parsed, j + pi.parsed + 2) !== "?>") {
+                this.onError(XMLParserErrorCode.UnterminatedXmlDeclaration);
                 return;
               }
 
-              if (q2 > 0 && q > q2) {
-                q = s.indexOf("]>", j + 8);
+              this.onPi(pi.name, pi.value);
+              j += pi.parsed + 2;
+              break;
+
+            case "!":
+              if (s.substring(j + 1, j + 3) === "--") {
+                q = s.indexOf("-->", j + 3);
 
                 if (q < 0) {
-                  this.onError(XMLParserErrorCode.UnterminatedDoctypeDeclaration);
+                  this.onError(XMLParserErrorCode.UnterminatedComment);
                   return;
                 }
 
-                complexDoctype = true;
-              }
+                this.onComment(s.substring(j + 3, q));
+                j = q + 3;
+              } else if (s.substring(j + 1, j + 8) === "[CDATA[") {
+                q = s.indexOf("]]>", j + 8);
 
-              const doctypeContent = s.substring(j + 8, q + (complexDoctype ? 1 : 0));
-              this.onDoctype(doctypeContent);
-              j = q + (complexDoctype ? 2 : 1);
-            } else {
-              this.onError(XMLParserErrorCode.MalformedElement);
-              return;
-            }
-
-            break;
-
-          default:
-            const content = this._parseContent(s, j);
-
-            if (content === null) {
-              this.onError(XMLParserErrorCode.MalformedElement);
-              return;
-            }
+                if (q < 0) {
+                  this.onError(XMLParserErrorCode.UnterminatedCdat);
+                  return;
+                }
 
-            let isClosed = false;
+                this.onCdata(s.substring(j + 8, q));
+                j = q + 3;
+              } else if (s.substring(j + 1, j + 8) === "DOCTYPE") {
+                var q2 = s.indexOf("[", j + 8);
+                var complexDoctype = false;
+                q = s.indexOf(">", j + 8);
 
-            if (s.substring(j + content.parsed, j + content.parsed + 2) === "/>") {
-              isClosed = true;
-            } else if (s.substring(j + content.parsed, j + content.parsed + 1) !== ">") {
-              this.onError(XMLParserErrorCode.UnterminatedElement);
-              return;
-            }
+                if (q < 0) {
+                  this.onError(XMLParserErrorCode.UnterminatedDoctypeDeclaration);
+                  return;
+                }
 
-            this.onBeginElement(content.name, content.attributes, isClosed);
-            j += content.parsed + (isClosed ? 2 : 1);
-            break;
-        }
-      } else {
-        while (j < s.length && s[j] !== "<") {
-          j++;
-        }
+                if (q2 > 0 && q > q2) {
+                  q = s.indexOf("]>", j + 8);
 
-        const text = s.substring(i, j);
-        this.onText(this._resolveEntities(text));
-      }
+                  if (q < 0) {
+                    this.onError(XMLParserErrorCode.UnterminatedDoctypeDeclaration);
+                    return;
+                  }
 
-      i = j;
-    }
-  }
+                  complexDoctype = true;
+                }
 
-  onResolveEntity(name) {
-    return `&${name};`;
-  }
+                var doctypeContent = s.substring(j + 8, q + (complexDoctype ? 1 : 0));
+                this.onDoctype(doctypeContent);
+                j = q + (complexDoctype ? 2 : 1);
+              } else {
+                this.onError(XMLParserErrorCode.MalformedElement);
+                return;
+              }
 
-  onPi(name, value) {}
+              break;
 
-  onComment(text) {}
+            default:
+              var content = this._parseContent(s, j);
 
-  onCdata(text) {}
+              if (content === null) {
+                this.onError(XMLParserErrorCode.MalformedElement);
+                return;
+              }
 
-  onDoctype(doctypeContent) {}
+              var isClosed = false;
 
-  onText(text) {}
+              if (s.substring(j + content.parsed, j + content.parsed + 2) === "/>") {
+                isClosed = true;
+              } else if (s.substring(j + content.parsed, j + content.parsed + 1) !== ">") {
+                this.onError(XMLParserErrorCode.UnterminatedElement);
+                return;
+              }
 
-  onBeginElement(name, attributes, isEmpty) {}
+              this.onBeginElement(content.name, content.attributes, isClosed);
+              j += content.parsed + (isClosed ? 2 : 1);
+              break;
+          }
+        } else {
+          while (j < s.length && s[j] !== "<") {
+            j++;
+          }
 
-  onEndElement(name) {}
+          var text = s.substring(i, j);
+          this.onText(this._resolveEntities(text));
+        }
 
-  onError(code) {}
+        i = j;
+      }
+    }
+  }, {
+    key: "onResolveEntity",
+    value: function onResolveEntity(name) {
+      return "&".concat(name, ";");
+    }
+  }, {
+    key: "onPi",
+    value: function onPi(name, value) {}
+  }, {
+    key: "onComment",
+    value: function onComment(text) {}
+  }, {
+    key: "onCdata",
+    value: function onCdata(text) {}
+  }, {
+    key: "onDoctype",
+    value: function onDoctype(doctypeContent) {}
+  }, {
+    key: "onText",
+    value: function onText(text) {}
+  }, {
+    key: "onBeginElement",
+    value: function onBeginElement(name, attributes, isEmpty) {}
+  }, {
+    key: "onEndElement",
+    value: function onEndElement(name) {}
+  }, {
+    key: "onError",
+    value: function onError(code) {}
+  }]);
+
+  return XMLParserBase;
+}();
 
-}
+var SimpleDOMNode = /*#__PURE__*/function () {
+  function SimpleDOMNode(nodeName, nodeValue) {
+    _classCallCheck(this, SimpleDOMNode);
 
-class SimpleDOMNode {
-  constructor(nodeName, nodeValue) {
     this.nodeName = nodeName;
     this.nodeValue = nodeValue;
     Object.defineProperty(this, "parentNode", {
@@ -7704,134 +18708,161 @@ class SimpleDOMNode {
     });
   }
 
-  get firstChild() {
-    return this.childNodes && this.childNodes[0];
-  }
+  _createClass(SimpleDOMNode, [{
+    key: "hasChildNodes",
+    value: function hasChildNodes() {
+      return this.childNodes && this.childNodes.length > 0;
+    }
+  }, {
+    key: "firstChild",
+    get: function get() {
+      return this.childNodes && this.childNodes[0];
+    }
+  }, {
+    key: "nextSibling",
+    get: function get() {
+      var childNodes = this.parentNode.childNodes;
 
-  get nextSibling() {
-    const childNodes = this.parentNode.childNodes;
+      if (!childNodes) {
+        return undefined;
+      }
 
-    if (!childNodes) {
-      return undefined;
-    }
+      var index = childNodes.indexOf(this);
 
-    const index = childNodes.indexOf(this);
+      if (index === -1) {
+        return undefined;
+      }
 
-    if (index === -1) {
-      return undefined;
+      return childNodes[index + 1];
     }
+  }, {
+    key: "textContent",
+    get: function get() {
+      if (!this.childNodes) {
+        return this.nodeValue || "";
+      }
 
-    return childNodes[index + 1];
-  }
-
-  get textContent() {
-    if (!this.childNodes) {
-      return this.nodeValue || "";
+      return this.childNodes.map(function (child) {
+        return child.textContent;
+      }).join("");
     }
+  }]);
 
-    return this.childNodes.map(function (child) {
-      return child.textContent;
-    }).join("");
-  }
+  return SimpleDOMNode;
+}();
 
-  hasChildNodes() {
-    return this.childNodes && this.childNodes.length > 0;
-  }
+var SimpleXMLParser = /*#__PURE__*/function (_XMLParserBase) {
+  _inherits(SimpleXMLParser, _XMLParserBase);
 
-}
+  var _super = _createSuper(SimpleXMLParser);
 
-class SimpleXMLParser extends XMLParserBase {
-  constructor() {
-    super();
-    this._currentFragment = null;
-    this._stack = null;
-    this._errorCode = XMLParserErrorCode.NoError;
-  }
+  function SimpleXMLParser() {
+    var _this2;
 
-  parseFromString(data) {
-    this._currentFragment = [];
-    this._stack = [];
-    this._errorCode = XMLParserErrorCode.NoError;
-    this.parseXml(data);
+    _classCallCheck(this, SimpleXMLParser);
 
-    if (this._errorCode !== XMLParserErrorCode.NoError) {
-      return undefined;
-    }
+    _this2 = _super.call(this);
+    _this2._currentFragment = null;
+    _this2._stack = null;
+    _this2._errorCode = XMLParserErrorCode.NoError;
+    return _this2;
+  }
 
-    const [documentElement] = this._currentFragment;
+  _createClass(SimpleXMLParser, [{
+    key: "parseFromString",
+    value: function parseFromString(data) {
+      this._currentFragment = [];
+      this._stack = [];
+      this._errorCode = XMLParserErrorCode.NoError;
+      this.parseXml(data);
 
-    if (!documentElement) {
-      return undefined;
-    }
+      if (this._errorCode !== XMLParserErrorCode.NoError) {
+        return undefined;
+      }
 
-    return {
-      documentElement
-    };
-  }
+      var _this$_currentFragmen = _slicedToArray(this._currentFragment, 1),
+          documentElement = _this$_currentFragmen[0];
 
-  onResolveEntity(name) {
-    switch (name) {
-      case "apos":
-        return "'";
-    }
+      if (!documentElement) {
+        return undefined;
+      }
 
-    return super.onResolveEntity(name);
-  }
+      return {
+        documentElement: documentElement
+      };
+    }
+  }, {
+    key: "onResolveEntity",
+    value: function onResolveEntity(name) {
+      switch (name) {
+        case "apos":
+          return "'";
+      }
 
-  onText(text) {
-    if (isWhitespaceString(text)) {
-      return;
+      return _get(_getPrototypeOf(SimpleXMLParser.prototype), "onResolveEntity", this).call(this, name);
     }
+  }, {
+    key: "onText",
+    value: function onText(text) {
+      if (isWhitespaceString(text)) {
+        return;
+      }
 
-    const node = new SimpleDOMNode("#text", text);
+      var node = new SimpleDOMNode("#text", text);
 
-    this._currentFragment.push(node);
-  }
+      this._currentFragment.push(node);
+    }
+  }, {
+    key: "onCdata",
+    value: function onCdata(text) {
+      var node = new SimpleDOMNode("#text", text);
 
-  onCdata(text) {
-    const node = new SimpleDOMNode("#text", text);
+      this._currentFragment.push(node);
+    }
+  }, {
+    key: "onBeginElement",
+    value: function onBeginElement(name, attributes, isEmpty) {
+      var node = new SimpleDOMNode(name);
+      node.childNodes = [];
 
-    this._currentFragment.push(node);
-  }
+      this._currentFragment.push(node);
 
-  onBeginElement(name, attributes, isEmpty) {
-    const node = new SimpleDOMNode(name);
-    node.childNodes = [];
+      if (isEmpty) {
+        return;
+      }
 
-    this._currentFragment.push(node);
+      this._stack.push(this._currentFragment);
 
-    if (isEmpty) {
-      return;
+      this._currentFragment = node.childNodes;
     }
+  }, {
+    key: "onEndElement",
+    value: function onEndElement(name) {
+      this._currentFragment = this._stack.pop() || [];
+      var lastElement = this._currentFragment[this._currentFragment.length - 1];
 
-    this._stack.push(this._currentFragment);
-
-    this._currentFragment = node.childNodes;
-  }
-
-  onEndElement(name) {
-    this._currentFragment = this._stack.pop() || [];
-    const lastElement = this._currentFragment[this._currentFragment.length - 1];
+      if (!lastElement) {
+        return;
+      }
 
-    if (!lastElement) {
-      return;
+      for (var i = 0, ii = lastElement.childNodes.length; i < ii; i++) {
+        lastElement.childNodes[i].parentNode = lastElement;
+      }
     }
-
-    for (let i = 0, ii = lastElement.childNodes.length; i < ii; i++) {
-      lastElement.childNodes[i].parentNode = lastElement;
+  }, {
+    key: "onError",
+    value: function onError(code) {
+      this._errorCode = code;
     }
-  }
+  }]);
 
-  onError(code) {
-    this._errorCode = code;
-  }
-
-}
+  return SimpleXMLParser;
+}(XMLParserBase);
 
 exports.SimpleXMLParser = SimpleXMLParser;
 
 /***/ }),
-/* 14 */
+/* 207 */
 /***/ (function(module, exports, __w_pdfjs_require__) {
 
 "use strict";
@@ -7842,17 +18873,41 @@ Object.defineProperty(exports, "__esModule", {
 });
 exports.PDFDataTransportStream = void 0;
 
-var _util = __w_pdfjs_require__(2);
+var _regenerator = _interopRequireDefault(__w_pdfjs_require__(2));
+
+var _util = __w_pdfjs_require__(5);
+
+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 _createForOfIteratorHelper(o, allowArrayLike) { var it; if (typeof Symbol === "undefined" || o[Symbol.iterator] == null) { if (Array.isArray(o) || (it = _unsupportedIterableToArray(o)) || allowArrayLike && o && typeof o.length === "number") { if (it) o = it; var i = 0; var F = function F() {}; return { s: F, n: function n() { if (i >= o.length) return { done: true }; return { done: false, value: o[i++] }; }, e: function e(_e) { throw _e; }, f: F }; } throw new TypeError("Invalid attempt to iterate non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method."); } var normalCompletion = true, didErr = false, err; return { s: function s() { it = o[Symbol.iterator](); }, n: function n() { var step = it.next(); normalCompletion = step.done; return step; }, e: function e(_e2) { didErr = true; err = _e2; }, f: function f() { try { if (!normalCompletion && it["return"] != null) it["return"](); } finally { if (didErr) throw err; } } }; }
+
+function _unsupportedIterableToArray(o, minLen) { if (!o) return; if (typeof o === "string") return _arrayLikeToArray(o, minLen); var n = Object.prototype.toString.call(o).slice(8, -1); if (n === "Object" && o.constructor) n = o.constructor.name; if (n === "Map" || n === "Set") return Array.from(o); if (n === "Arguments" || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(n)) return _arrayLikeToArray(o, minLen); }
+
+function _arrayLikeToArray(arr, len) { if (len == null || len > arr.length) len = arr.length; for (var i = 0, arr2 = new Array(len); i < len; i++) { arr2[i] = arr[i]; } return arr2; }
+
+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);
 
-class PDFDataTransportStream {
-  constructor(params, pdfDataRangeTransport) {
     (0, _util.assert)(pdfDataRangeTransport, 'PDFDataTransportStream - missing required "pdfDataRangeTransport" argument.');
     this._queuedChunks = [];
     this._progressiveDone = params.progressiveDone || false;
-    const initialData = params.initialData;
+    var initialData = params.initialData;
 
     if (initialData && initialData.length > 0) {
-      const buffer = new Uint8Array(initialData).buffer;
+      var buffer = new Uint8Array(initialData).buffer;
 
       this._queuedChunks.push(buffer);
     }
@@ -7864,147 +18919,172 @@ class PDFDataTransportStream {
     this._fullRequestReader = null;
     this._rangeReaders = [];
 
-    this._pdfDataRangeTransport.addRangeListener((begin, chunk) => {
-      this._onReceiveData({
-        begin,
-        chunk
+    this._pdfDataRangeTransport.addRangeListener(function (begin, chunk) {
+      _this._onReceiveData({
+        begin: begin,
+        chunk: chunk
       });
     });
 
-    this._pdfDataRangeTransport.addProgressListener((loaded, total) => {
-      this._onProgress({
-        loaded,
-        total
+    this._pdfDataRangeTransport.addProgressListener(function (loaded, total) {
+      _this._onProgress({
+        loaded: loaded,
+        total: total
       });
     });
 
-    this._pdfDataRangeTransport.addProgressiveReadListener(chunk => {
-      this._onReceiveData({
-        chunk
+    this._pdfDataRangeTransport.addProgressiveReadListener(function (chunk) {
+      _this._onReceiveData({
+        chunk: chunk
       });
     });
 
-    this._pdfDataRangeTransport.addProgressiveDoneListener(() => {
-      this._onProgressiveDone();
+    this._pdfDataRangeTransport.addProgressiveDoneListener(function () {
+      _this._onProgressiveDone();
     });
 
     this._pdfDataRangeTransport.transportReady();
   }
 
-  _onReceiveData(args) {
-    const buffer = new Uint8Array(args.chunk).buffer;
+  _createClass(PDFDataTransportStream, [{
+    key: "_onReceiveData",
+    value: function _onReceiveData(args) {
+      var buffer = new Uint8Array(args.chunk).buffer;
 
-    if (args.begin === undefined) {
-      if (this._fullRequestReader) {
-        this._fullRequestReader._enqueue(buffer);
-      } else {
-        this._queuedChunks.push(buffer);
-      }
-    } else {
-      const found = this._rangeReaders.some(function (rangeReader) {
-        if (rangeReader._begin !== args.begin) {
-          return false;
+      if (args.begin === undefined) {
+        if (this._fullRequestReader) {
+          this._fullRequestReader._enqueue(buffer);
+        } else {
+          this._queuedChunks.push(buffer);
         }
+      } else {
+        var 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, "_onReceiveData - no `PDFDataTransportStreamRangeReader` instance found.");
+        (0, _util.assert)(found, "_onReceiveData - no `PDFDataTransportStreamRangeReader` instance found.");
+      }
     }
-  }
-
-  get _progressiveDataLength() {
-    return this._fullRequestReader ? this._fullRequestReader._loaded : 0;
-  }
-
-  _onProgress(evt) {
-    if (evt.total === undefined) {
-      const firstReader = this._rangeReaders[0];
+  }, {
+    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 {
-      const fullReader = this._fullRequestReader;
+        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
-        });
+        if (fullReader && fullReader.onProgress) {
+          fullReader.onProgress({
+            loaded: evt.loaded,
+            total: evt.total
+          });
+        }
       }
     }
-  }
+  }, {
+    key: "_onProgressiveDone",
+    value: function _onProgressiveDone() {
+      if (this._fullRequestReader) {
+        this._fullRequestReader.progressiveDone();
+      }
 
-  _onProgressiveDone() {
-    if (this._fullRequestReader) {
-      this._fullRequestReader.progressiveDone();
+      this._progressiveDone = true;
     }
+  }, {
+    key: "_removeRangeReader",
+    value: function _removeRangeReader(reader) {
+      var i = this._rangeReaders.indexOf(reader);
 
-    this._progressiveDone = true;
-  }
-
-  _removeRangeReader(reader) {
-    const i = this._rangeReaders.indexOf(reader);
-
-    if (i >= 0) {
-      this._rangeReaders.splice(i, 1);
+      if (i >= 0) {
+        this._rangeReaders.splice(i, 1);
+      }
     }
-  }
-
-  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);
-  }
-
-  getRangeReader(begin, end) {
-    if (end <= this._progressiveDataLength) {
-      return null;
+  }, {
+    key: "getFullReader",
+    value: function getFullReader() {
+      (0, _util.assert)(!this._fullRequestReader, "PDFDataTransportStream.getFullReader can only be called once.");
+      var queuedChunks = this._queuedChunks;
+      this._queuedChunks = null;
+      return new PDFDataTransportStreamReader(this, queuedChunks, this._progressiveDone);
     }
+  }, {
+    key: "getRangeReader",
+    value: function getRangeReader(begin, end) {
+      if (end <= this._progressiveDataLength) {
+        return null;
+      }
 
-    const reader = new PDFDataTransportStreamRangeReader(this, begin, end);
-
-    this._pdfDataRangeTransport.requestDataRange(begin, end);
+      var reader = new PDFDataTransportStreamRangeReader(this, begin, end);
 
-    this._rangeReaders.push(reader);
+      this._pdfDataRangeTransport.requestDataRange(begin, end);
 
-    return reader;
-  }
+      this._rangeReaders.push(reader);
 
-  cancelAllRequests(reason) {
-    if (this._fullRequestReader) {
-      this._fullRequestReader.cancel(reason);
+      return reader;
     }
+  }, {
+    key: "cancelAllRequests",
+    value: function cancelAllRequests(reason) {
+      if (this._fullRequestReader) {
+        this._fullRequestReader.cancel(reason);
+      }
 
-    const readers = this._rangeReaders.slice(0);
+      var readers = this._rangeReaders.slice(0);
 
-    readers.forEach(function (rangeReader) {
-      rangeReader.cancel(reason);
-    });
+      readers.forEach(function (rangeReader) {
+        rangeReader.cancel(reason);
+      });
 
-    this._pdfDataRangeTransport.abort();
-  }
+      this._pdfDataRangeTransport.abort();
+    }
+  }, {
+    key: "_progressiveDataLength",
+    get: function get() {
+      return this._fullRequestReader ? this._fullRequestReader._loaded : 0;
+    }
+  }]);
 
-}
+  return PDFDataTransportStream;
+}();
 
 exports.PDFDataTransportStream = PDFDataTransportStream;
 
-class PDFDataTransportStreamReader {
-  constructor(stream, queuedChunks, progressiveDone = false) {
+var PDFDataTransportStreamReader = /*#__PURE__*/function () {
+  function PDFDataTransportStreamReader(stream, queuedChunks) {
+    var progressiveDone = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : false;
+
+    _classCallCheck(this, PDFDataTransportStreamReader);
+
     this._stream = stream;
     this._done = progressiveDone || false;
     this._filename = null;
     this._queuedChunks = queuedChunks || [];
     this._loaded = 0;
 
-    for (const chunk of this._queuedChunks) {
-      this._loaded += chunk.byteLength;
+    var _iterator = _createForOfIteratorHelper(this._queuedChunks),
+        _step;
+
+    try {
+      for (_iterator.s(); !(_step = _iterator.n()).done;) {
+        var chunk = _step.value;
+        this._loaded += chunk.byteLength;
+      }
+    } catch (err) {
+      _iterator.e(err);
+    } finally {
+      _iterator.f();
     }
 
     this._requests = [];
@@ -8013,94 +19093,135 @@ class PDFDataTransportStreamReader {
     this.onProgress = null;
   }
 
-  _enqueue(chunk) {
-    if (this._done) {
-      return;
-    }
-
-    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;
-  }
+  _createClass(PDFDataTransportStreamReader, [{
+    key: "_enqueue",
+    value: function _enqueue(chunk) {
+      if (this._done) {
+        return;
+      }
 
-  get headersReady() {
-    return this._headersReady;
-  }
+      if (this._requests.length > 0) {
+        var requestCapability = this._requests.shift();
 
-  get filename() {
-    return this._filename;
-  }
+        requestCapability.resolve({
+          value: chunk,
+          done: false
+        });
+      } else {
+        this._queuedChunks.push(chunk);
+      }
 
-  get isRangeSupported() {
-    return this._stream._isRangeSupported;
-  }
+      this._loaded += chunk.byteLength;
+    }
+  }, {
+    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;
+                }
 
-  get isStreamingSupported() {
-    return this._stream._isStreamingSupported;
-  }
+                chunk = this._queuedChunks.shift();
+                return _context.abrupt("return", {
+                  value: chunk,
+                  done: false
+                });
 
-  get contentLength() {
-    return this._stream._contentLength;
-  }
+              case 3:
+                if (!this._done) {
+                  _context.next = 5;
+                  break;
+                }
 
-  async read() {
-    if (this._queuedChunks.length > 0) {
-      const chunk = this._queuedChunks.shift();
+                return _context.abrupt("return", {
+                  value: undefined,
+                  done: true
+                });
 
-      return {
-        value: chunk,
-        done: false
-      };
-    }
+              case 5:
+                requestCapability = (0, _util.createPromiseCapability)();
 
-    if (this._done) {
-      return {
-        value: undefined,
-        done: true
-      };
-    }
+                this._requests.push(requestCapability);
 
-    const requestCapability = (0, _util.createPromiseCapability)();
+                return _context.abrupt("return", requestCapability.promise);
 
-    this._requests.push(requestCapability);
+              case 8:
+              case "end":
+                return _context.stop();
+            }
+          }
+        }, _callee, this);
+      }));
 
-    return requestCapability.promise;
-  }
+      function read() {
+        return _read.apply(this, arguments);
+      }
 
-  cancel(reason) {
-    this._done = true;
+      return read;
+    }()
+  }, {
+    key: "cancel",
+    value: function cancel(reason) {
+      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 = [];
+    }
+  }, {
+    key: "progressiveDone",
+    value: function progressiveDone() {
+      if (this._done) {
+        return;
+      }
 
-  progressiveDone() {
-    if (this._done) {
-      return;
+      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;
+    }
+  }, {
+    key: "isStreamingSupported",
+    get: function get() {
+      return this._stream._isStreamingSupported;
+    }
+  }, {
+    key: "contentLength",
+    get: function get() {
+      return this._stream._contentLength;
+    }
+  }]);
 
-    this._done = true;
-  }
+  return PDFDataTransportStreamReader;
+}();
 
-}
+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;
@@ -8110,83 +19231,118 @@ class PDFDataTransportStreamRangeReader {
     this.onProgress = null;
   }
 
-  _enqueue(chunk) {
-    if (this._done) {
-      return;
-    }
+  _createClass(PDFDataTransportStreamRangeReader, [{
+    key: "_enqueue",
+    value: function _enqueue(chunk) {
+      if (this._done) {
+        return;
+      }
 
-    if (this._requests.length === 0) {
-      this._queuedChunk = chunk;
-    } else {
-      const requestsCapability = this._requests.shift();
+      if (this._requests.length === 0) {
+        this._queuedChunk = chunk;
+      } else {
+        var requestsCapability = this._requests.shift();
 
-      requestsCapability.resolve({
-        value: chunk,
-        done: false
-      });
+        requestsCapability.resolve({
+          value: chunk,
+          done: false
+        });
 
-      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._done = true;
+      this._done = true;
 
-    this._stream._removeRangeReader(this);
-  }
+      this._stream._removeRangeReader(this);
+    }
+  }, {
+    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;
+                }
 
-  get isStreamingSupported() {
-    return false;
-  }
+                chunk = this._queuedChunk;
+                this._queuedChunk = null;
+                return _context2.abrupt("return", {
+                  value: chunk,
+                  done: false
+                });
+
+              case 4:
+                if (!this._done) {
+                  _context2.next = 6;
+                  break;
+                }
 
-  async read() {
-    if (this._queuedChunk) {
-      const chunk = this._queuedChunk;
-      this._queuedChunk = null;
-      return {
-        value: chunk,
-        done: false
-      };
-    }
+                return _context2.abrupt("return", {
+                  value: undefined,
+                  done: true
+                });
 
-    if (this._done) {
-      return {
-        value: undefined,
-        done: true
-      };
-    }
+              case 6:
+                requestCapability = (0, _util.createPromiseCapability)();
 
-    const requestCapability = (0, _util.createPromiseCapability)();
+                this._requests.push(requestCapability);
 
-    this._requests.push(requestCapability);
+                return _context2.abrupt("return", requestCapability.promise);
 
-    return requestCapability.promise;
-  }
+              case 9:
+              case "end":
+                return _context2.stop();
+            }
+          }
+        }, _callee2, this);
+      }));
 
-  cancel(reason) {
-    this._done = true;
+      function read() {
+        return _read2.apply(this, arguments);
+      }
 
-    this._requests.forEach(function (requestCapability) {
-      requestCapability.resolve({
-        value: undefined,
-        done: true
+      return read;
+    }()
+  }, {
+    key: "cancel",
+    value: function cancel(reason) {
+      this._done = true;
+
+      this._requests.forEach(function (requestCapability) {
+        requestCapability.resolve({
+          value: undefined,
+          done: true
+        });
       });
-    });
 
-    this._requests = [];
+      this._requests = [];
 
-    this._stream._removeRangeReader(this);
-  }
+      this._stream._removeRangeReader(this);
+    }
+  }, {
+    key: "isStreamingSupported",
+    get: function get() {
+      return false;
+    }
+  }]);
 
-}
+  return PDFDataTransportStreamRangeReader;
+}();
 
 /***/ }),
-/* 15 */
+/* 208 */
 /***/ (function(module, exports, __w_pdfjs_require__) {
 
 "use strict";
@@ -8197,48 +19353,62 @@ Object.defineProperty(exports, "__esModule", {
 });
 exports.WebGLContext = void 0;
 
-var _util = __w_pdfjs_require__(2);
+var _util = __w_pdfjs_require__(5);
 
-class WebGLContext {
-  constructor({
-    enable = false
-  }) {
-    this._enabled = enable === true;
-  }
+function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }
 
-  get isEnabled() {
-    let enabled = this._enabled;
+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); } }
 
-    if (enabled) {
-      enabled = WebGLUtils.tryInitGL();
-    }
+function _createClass(Constructor, protoProps, staticProps) { if (protoProps) _defineProperties(Constructor.prototype, protoProps); if (staticProps) _defineProperties(Constructor, staticProps); return Constructor; }
 
-    return (0, _util.shadow)(this, "isEnabled", enabled);
-  }
+var WebGLContext = /*#__PURE__*/function () {
+  function WebGLContext(_ref) {
+    var _ref$enable = _ref.enable,
+        enable = _ref$enable === void 0 ? false : _ref$enable;
 
-  composeSMask({
-    layer,
-    mask,
-    properties
-  }) {
-    return WebGLUtils.composeSMask(layer, mask, properties);
-  }
+    _classCallCheck(this, WebGLContext);
 
-  drawFigures({
-    width,
-    height,
-    backgroundColor,
-    figures,
-    context
-  }) {
-    return WebGLUtils.drawFigures(width, height, backgroundColor, figures, context);
+    this._enabled = enable === true;
   }
 
-  clear() {
-    WebGLUtils.cleanup();
-  }
+  _createClass(WebGLContext, [{
+    key: "composeSMask",
+    value: function composeSMask(_ref2) {
+      var layer = _ref2.layer,
+          mask = _ref2.mask,
+          properties = _ref2.properties;
+      return WebGLUtils.composeSMask(layer, mask, properties);
+    }
+  }, {
+    key: "drawFigures",
+    value: function drawFigures(_ref3) {
+      var width = _ref3.width,
+          height = _ref3.height,
+          backgroundColor = _ref3.backgroundColor,
+          figures = _ref3.figures,
+          context = _ref3.context;
+      return WebGLUtils.drawFigures(width, height, backgroundColor, figures, context);
+    }
+  }, {
+    key: "clear",
+    value: function clear() {
+      WebGLUtils.cleanup();
+    }
+  }, {
+    key: "isEnabled",
+    get: function get() {
+      var enabled = this._enabled;
 
-}
+      if (enabled) {
+        enabled = WebGLUtils.tryInitGL();
+      }
+
+      return (0, _util.shadow)(this, "isEnabled", enabled);
+    }
+  }]);
+
+  return WebGLContext;
+}();
 
 exports.WebGLContext = WebGLContext;
 
@@ -8602,7 +19772,7 @@ var WebGLUtils = function WebGLUtilsClosure() {
   }
 
   return {
-    tryInitGL() {
+    tryInitGL: function tryInitGL() {
       try {
         generateGL();
         return !!currentGL;
@@ -8610,11 +19780,9 @@ var WebGLUtils = function WebGLUtilsClosure() {
 
       return false;
     },
-
-    composeSMask,
-    drawFigures,
-
-    cleanup() {
+    composeSMask: composeSMask,
+    drawFigures: drawFigures,
+    cleanup: function cleanup() {
       if (smaskCache && smaskCache.canvas) {
         smaskCache.canvas.width = 0;
         smaskCache.canvas.height = 0;
@@ -8628,12 +19796,11 @@ var WebGLUtils = function WebGLUtilsClosure() {
       smaskCache = null;
       figuresCache = null;
     }
-
   };
 }();
 
 /***/ }),
-/* 16 */
+/* 209 */
 /***/ (function(module, exports, __w_pdfjs_require__) {
 
 "use strict";
@@ -8646,95 +19813,140 @@ exports.AnnotationLayer = void 0;
 
 var _display_utils = __w_pdfjs_require__(1);
 
-var _util = __w_pdfjs_require__(2);
+var _util = __w_pdfjs_require__(5);
 
-class AnnotationElementFactory {
-  static create(parameters) {
-    const subtype = parameters.data.annotationType;
+function _createForOfIteratorHelper(o, allowArrayLike) { var it; if (typeof Symbol === "undefined" || o[Symbol.iterator] == null) { if (Array.isArray(o) || (it = _unsupportedIterableToArray(o)) || allowArrayLike && o && typeof o.length === "number") { if (it) o = it; var i = 0; var F = function F() {}; return { s: F, n: function n() { if (i >= o.length) return { done: true }; return { done: false, value: o[i++] }; }, e: function e(_e) { throw _e; }, f: F }; } throw new TypeError("Invalid attempt to iterate non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method."); } var normalCompletion = true, didErr = false, err; return { s: function s() { it = o[Symbol.iterator](); }, n: function n() { var step = it.next(); normalCompletion = step.done; return step; }, e: function e(_e2) { didErr = true; err = _e2; }, f: function f() { try { if (!normalCompletion && it["return"] != null) it["return"](); } finally { if (didErr) throw err; } } }; }
 
-    switch (subtype) {
-      case _util.AnnotationType.LINK:
-        return new LinkAnnotationElement(parameters);
+function _unsupportedIterableToArray(o, minLen) { if (!o) return; if (typeof o === "string") return _arrayLikeToArray(o, minLen); var n = Object.prototype.toString.call(o).slice(8, -1); if (n === "Object" && o.constructor) n = o.constructor.name; if (n === "Map" || n === "Set") return Array.from(o); if (n === "Arguments" || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(n)) return _arrayLikeToArray(o, minLen); }
 
-      case _util.AnnotationType.TEXT:
-        return new TextAnnotationElement(parameters);
+function _arrayLikeToArray(arr, len) { if (len == null || len > arr.length) len = arr.length; for (var i = 0, arr2 = new Array(len); i < len; i++) { arr2[i] = arr[i]; } return arr2; }
 
-      case _util.AnnotationType.WIDGET:
-        const fieldType = parameters.data.fieldType;
+function _get(target, property, receiver) { if (typeof Reflect !== "undefined" && Reflect.get) { _get = Reflect.get; } else { _get = function _get(target, property, receiver) { var base = _superPropBase(target, property); if (!base) return; var desc = Object.getOwnPropertyDescriptor(base, property); if (desc.get) { return desc.get.call(receiver); } return desc.value; }; } return _get(target, property, receiver || target); }
 
-        switch (fieldType) {
-          case "Tx":
-            return new TextWidgetAnnotationElement(parameters);
+function _superPropBase(object, property) { while (!Object.prototype.hasOwnProperty.call(object, property)) { object = _getPrototypeOf(object); if (object === null) break; } return object; }
 
-          case "Btn":
-            if (parameters.data.radioButton) {
-              return new RadioButtonWidgetAnnotationElement(parameters);
-            } else if (parameters.data.checkBox) {
-              return new CheckboxWidgetAnnotationElement(parameters);
-            }
+function _typeof(obj) { "@babel/helpers - typeof"; 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); }
 
-            return new PushButtonWidgetAnnotationElement(parameters);
+function _inherits(subClass, superClass) { if (typeof superClass !== "function" && superClass !== null) { throw new TypeError("Super expression must either be null or a function"); } subClass.prototype = Object.create(superClass && superClass.prototype, { constructor: { value: subClass, writable: true, configurable: true } }); if (superClass) _setPrototypeOf(subClass, superClass); }
 
-          case "Ch":
-            return new ChoiceWidgetAnnotationElement(parameters);
-        }
+function _setPrototypeOf(o, p) { _setPrototypeOf = Object.setPrototypeOf || function _setPrototypeOf(o, p) { o.__proto__ = p; return o; }; return _setPrototypeOf(o, p); }
 
-        return new WidgetAnnotationElement(parameters);
+function _createSuper(Derived) { var hasNativeReflectConstruct = _isNativeReflectConstruct(); return function _createSuperInternal() { var Super = _getPrototypeOf(Derived), result; if (hasNativeReflectConstruct) { var NewTarget = _getPrototypeOf(this).constructor; result = Reflect.construct(Super, arguments, NewTarget); } else { result = Super.apply(this, arguments); } return _possibleConstructorReturn(this, result); }; }
 
-      case _util.AnnotationType.POPUP:
-        return new PopupAnnotationElement(parameters);
+function _possibleConstructorReturn(self, call) { if (call && (_typeof(call) === "object" || typeof call === "function")) { return call; } return _assertThisInitialized(self); }
 
-      case _util.AnnotationType.FREETEXT:
-        return new FreeTextAnnotationElement(parameters);
+function _assertThisInitialized(self) { if (self === void 0) { throw new ReferenceError("this hasn't been initialised - super() hasn't been called"); } return self; }
 
-      case _util.AnnotationType.LINE:
-        return new LineAnnotationElement(parameters);
+function _isNativeReflectConstruct() { if (typeof Reflect === "undefined" || !Reflect.construct) return false; if (Reflect.construct.sham) return false; if (typeof Proxy === "function") return true; try { Date.prototype.toString.call(Reflect.construct(Date, [], function () {})); return true; } catch (e) { return false; } }
 
-      case _util.AnnotationType.SQUARE:
-        return new SquareAnnotationElement(parameters);
+function _getPrototypeOf(o) { _getPrototypeOf = Object.setPrototypeOf ? Object.getPrototypeOf : function _getPrototypeOf(o) { return o.__proto__ || Object.getPrototypeOf(o); }; return _getPrototypeOf(o); }
 
-      case _util.AnnotationType.CIRCLE:
-        return new CircleAnnotationElement(parameters);
+function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }
 
-      case _util.AnnotationType.POLYLINE:
-        return new PolylineAnnotationElement(parameters);
+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); } }
 
-      case _util.AnnotationType.CARET:
-        return new CaretAnnotationElement(parameters);
+function _createClass(Constructor, protoProps, staticProps) { if (protoProps) _defineProperties(Constructor.prototype, protoProps); if (staticProps) _defineProperties(Constructor, staticProps); return Constructor; }
 
-      case _util.AnnotationType.INK:
-        return new InkAnnotationElement(parameters);
+var AnnotationElementFactory = /*#__PURE__*/function () {
+  function AnnotationElementFactory() {
+    _classCallCheck(this, AnnotationElementFactory);
+  }
 
-      case _util.AnnotationType.POLYGON:
-        return new PolygonAnnotationElement(parameters);
+  _createClass(AnnotationElementFactory, null, [{
+    key: "create",
+    value: function create(parameters) {
+      var subtype = parameters.data.annotationType;
 
-      case _util.AnnotationType.HIGHLIGHT:
-        return new HighlightAnnotationElement(parameters);
+      switch (subtype) {
+        case _util.AnnotationType.LINK:
+          return new LinkAnnotationElement(parameters);
 
-      case _util.AnnotationType.UNDERLINE:
-        return new UnderlineAnnotationElement(parameters);
+        case _util.AnnotationType.TEXT:
+          return new TextAnnotationElement(parameters);
 
-      case _util.AnnotationType.SQUIGGLY:
-        return new SquigglyAnnotationElement(parameters);
+        case _util.AnnotationType.WIDGET:
+          var fieldType = parameters.data.fieldType;
 
-      case _util.AnnotationType.STRIKEOUT:
-        return new StrikeOutAnnotationElement(parameters);
+          switch (fieldType) {
+            case "Tx":
+              return new TextWidgetAnnotationElement(parameters);
 
-      case _util.AnnotationType.STAMP:
-        return new StampAnnotationElement(parameters);
+            case "Btn":
+              if (parameters.data.radioButton) {
+                return new RadioButtonWidgetAnnotationElement(parameters);
+              } else if (parameters.data.checkBox) {
+                return new CheckboxWidgetAnnotationElement(parameters);
+              }
 
-      case _util.AnnotationType.FILEATTACHMENT:
-        return new FileAttachmentAnnotationElement(parameters);
+              return new PushButtonWidgetAnnotationElement(parameters);
 
-      default:
-        return new AnnotationElement(parameters);
+            case "Ch":
+              return new ChoiceWidgetAnnotationElement(parameters);
+          }
+
+          return new WidgetAnnotationElement(parameters);
+
+        case _util.AnnotationType.POPUP:
+          return new PopupAnnotationElement(parameters);
+
+        case _util.AnnotationType.FREETEXT:
+          return new FreeTextAnnotationElement(parameters);
+
+        case _util.AnnotationType.LINE:
+          return new LineAnnotationElement(parameters);
+
+        case _util.AnnotationType.SQUARE:
+          return new SquareAnnotationElement(parameters);
+
+        case _util.AnnotationType.CIRCLE:
+          return new CircleAnnotationElement(parameters);
+
+        case _util.AnnotationType.POLYLINE:
+          return new PolylineAnnotationElement(parameters);
+
+        case _util.AnnotationType.CARET:
+          return new CaretAnnotationElement(parameters);
+
+        case _util.AnnotationType.INK:
+          return new InkAnnotationElement(parameters);
+
+        case _util.AnnotationType.POLYGON:
+          return new PolygonAnnotationElement(parameters);
+
+        case _util.AnnotationType.HIGHLIGHT:
+          return new HighlightAnnotationElement(parameters);
+
+        case _util.AnnotationType.UNDERLINE:
+          return new UnderlineAnnotationElement(parameters);
+
+        case _util.AnnotationType.SQUIGGLY:
+          return new SquigglyAnnotationElement(parameters);
+
+        case _util.AnnotationType.STRIKEOUT:
+          return new StrikeOutAnnotationElement(parameters);
+
+        case _util.AnnotationType.STAMP:
+          return new StampAnnotationElement(parameters);
+
+        case _util.AnnotationType.FILEATTACHMENT:
+          return new FileAttachmentAnnotationElement(parameters);
+
+        default:
+          return new AnnotationElement(parameters);
+      }
     }
-  }
+  }]);
 
-}
+  return AnnotationElementFactory;
+}();
+
+var AnnotationElement = /*#__PURE__*/function () {
+  function AnnotationElement(parameters) {
+    var isRenderable = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : false;
+    var ignoreBorder = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : false;
+
+    _classCallCheck(this, AnnotationElement);
 
-class AnnotationElement {
-  constructor(parameters, isRenderable = false, ignoreBorder = false) {
     this.isRenderable = isRenderable;
     this.data = parameters.data;
     this.layer = parameters.layer;
@@ -8751,411 +19963,535 @@ class AnnotationElement {
     }
   }
 
-  _createContainer(ignoreBorder = false) {
-    const data = this.data,
+  _createClass(AnnotationElement, [{
+    key: "_createContainer",
+    value: function _createContainer() {
+      var ignoreBorder = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : false;
+      var data = this.data,
           page = this.page,
           viewport = this.viewport;
-    const container = document.createElement("section");
-    let width = data.rect[2] - data.rect[0];
-    let height = data.rect[3] - data.rect[1];
-    container.setAttribute("data-annotation-id", data.id);
+      var container = document.createElement("section");
+      var width = data.rect[2] - data.rect[0];
+      var height = data.rect[3] - data.rect[1];
+      container.setAttribute("data-annotation-id", data.id);
 
-    const rect = _util.Util.normalizeRect([data.rect[0], page.view[3] - data.rect[1] + page.view[1], data.rect[2], page.view[3] - data.rect[3] + page.view[1]]);
+      var rect = _util.Util.normalizeRect([data.rect[0], page.view[3] - data.rect[1] + page.view[1], data.rect[2], page.view[3] - data.rect[3] + page.view[1]]);
 
-    container.style.transform = `matrix(${viewport.transform.join(",")})`;
-    container.style.transformOrigin = `-${rect[0]}px -${rect[1]}px`;
+      container.style.transform = "matrix(".concat(viewport.transform.join(","), ")");
+      container.style.transformOrigin = "-".concat(rect[0], "px -").concat(rect[1], "px");
 
-    if (!ignoreBorder && data.borderStyle.width > 0) {
-      container.style.borderWidth = `${data.borderStyle.width}px`;
+      if (!ignoreBorder && data.borderStyle.width > 0) {
+        container.style.borderWidth = "".concat(data.borderStyle.width, "px");
 
-      if (data.borderStyle.style !== _util.AnnotationBorderStyleType.UNDERLINE) {
-        width = width - 2 * data.borderStyle.width;
-        height = height - 2 * data.borderStyle.width;
-      }
+        if (data.borderStyle.style !== _util.AnnotationBorderStyleType.UNDERLINE) {
+          width = width - 2 * data.borderStyle.width;
+          height = height - 2 * data.borderStyle.width;
+        }
 
-      const horizontalRadius = data.borderStyle.horizontalCornerRadius;
-      const verticalRadius = data.borderStyle.verticalCornerRadius;
+        var horizontalRadius = data.borderStyle.horizontalCornerRadius;
+        var verticalRadius = data.borderStyle.verticalCornerRadius;
 
-      if (horizontalRadius > 0 || verticalRadius > 0) {
-        const radius = `${horizontalRadius}px / ${verticalRadius}px`;
-        container.style.borderRadius = radius;
-      }
+        if (horizontalRadius > 0 || verticalRadius > 0) {
+          var radius = "".concat(horizontalRadius, "px / ").concat(verticalRadius, "px");
+          container.style.borderRadius = radius;
+        }
 
-      switch (data.borderStyle.style) {
-        case _util.AnnotationBorderStyleType.SOLID:
-          container.style.borderStyle = "solid";
-          break;
+        switch (data.borderStyle.style) {
+          case _util.AnnotationBorderStyleType.SOLID:
+            container.style.borderStyle = "solid";
+            break;
 
-        case _util.AnnotationBorderStyleType.DASHED:
-          container.style.borderStyle = "dashed";
-          break;
+          case _util.AnnotationBorderStyleType.DASHED:
+            container.style.borderStyle = "dashed";
+            break;
 
-        case _util.AnnotationBorderStyleType.BEVELED:
-          (0, _util.warn)("Unimplemented border style: beveled");
-          break;
+          case _util.AnnotationBorderStyleType.BEVELED:
+            (0, _util.warn)("Unimplemented border style: beveled");
+            break;
 
-        case _util.AnnotationBorderStyleType.INSET:
-          (0, _util.warn)("Unimplemented border style: inset");
-          break;
+          case _util.AnnotationBorderStyleType.INSET:
+            (0, _util.warn)("Unimplemented border style: inset");
+            break;
 
-        case _util.AnnotationBorderStyleType.UNDERLINE:
-          container.style.borderBottomStyle = "solid";
-          break;
+          case _util.AnnotationBorderStyleType.UNDERLINE:
+            container.style.borderBottomStyle = "solid";
+            break;
 
-        default:
-          break;
-      }
+          default:
+            break;
+        }
 
-      if (data.color) {
-        container.style.borderColor = _util.Util.makeCssRgb(data.color[0] | 0, data.color[1] | 0, data.color[2] | 0);
-      } else {
-        container.style.borderWidth = 0;
+        if (data.color) {
+          container.style.borderColor = _util.Util.makeCssRgb(data.color[0] | 0, data.color[1] | 0, data.color[2] | 0);
+        } else {
+          container.style.borderWidth = 0;
+        }
       }
+
+      container.style.left = "".concat(rect[0], "px");
+      container.style.top = "".concat(rect[1], "px");
+      container.style.width = "".concat(width, "px");
+      container.style.height = "".concat(height, "px");
+      return container;
+    }
+  }, {
+    key: "_createPopup",
+    value: function _createPopup(container, trigger, data) {
+      if (!trigger) {
+        trigger = document.createElement("div");
+        trigger.style.height = container.style.height;
+        trigger.style.width = container.style.width;
+        container.appendChild(trigger);
+      }
+
+      var popupElement = new PopupElement({
+        container: container,
+        trigger: trigger,
+        color: data.color,
+        title: data.title,
+        modificationDate: data.modificationDate,
+        contents: data.contents,
+        hideWrapper: true
+      });
+      var popup = popupElement.render();
+      popup.style.left = container.style.width;
+      container.appendChild(popup);
+    }
+  }, {
+    key: "render",
+    value: function render() {
+      (0, _util.unreachable)("Abstract method `AnnotationElement.render` called");
     }
+  }]);
 
-    container.style.left = `${rect[0]}px`;
-    container.style.top = `${rect[1]}px`;
-    container.style.width = `${width}px`;
-    container.style.height = `${height}px`;
-    return container;
-  }
+  return AnnotationElement;
+}();
 
-  _createPopup(container, trigger, data) {
-    if (!trigger) {
-      trigger = document.createElement("div");
-      trigger.style.height = container.style.height;
-      trigger.style.width = container.style.width;
-      container.appendChild(trigger);
-    }
+var LinkAnnotationElement = /*#__PURE__*/function (_AnnotationElement) {
+  _inherits(LinkAnnotationElement, _AnnotationElement);
 
-    const popupElement = new PopupElement({
-      container,
-      trigger,
-      color: data.color,
-      title: data.title,
-      modificationDate: data.modificationDate,
-      contents: data.contents,
-      hideWrapper: true
-    });
-    const popup = popupElement.render();
-    popup.style.left = container.style.width;
-    container.appendChild(popup);
-  }
+  var _super = _createSuper(LinkAnnotationElement);
+
+  function LinkAnnotationElement(parameters) {
+    _classCallCheck(this, LinkAnnotationElement);
 
-  render() {
-    (0, _util.unreachable)("Abstract method `AnnotationElement.render` called");
+    var isRenderable = !!(parameters.data.url || parameters.data.dest || parameters.data.action);
+    return _super.call(this, parameters, isRenderable);
   }
 
-}
+  _createClass(LinkAnnotationElement, [{
+    key: "render",
+    value: function render() {
+      this.container.className = "linkAnnotation";
+      var data = this.data,
+          linkService = this.linkService;
+      var link = document.createElement("a");
 
-class LinkAnnotationElement extends AnnotationElement {
-  constructor(parameters) {
-    const isRenderable = !!(parameters.data.url || parameters.data.dest || parameters.data.action);
-    super(parameters, isRenderable);
-  }
-
-  render() {
-    this.container.className = "linkAnnotation";
-    const {
-      data,
-      linkService
-    } = this;
-    const link = document.createElement("a");
-
-    if (data.url) {
-      (0, _display_utils.addLinkAttributes)(link, {
-        url: data.url,
-        target: data.newWindow ? _display_utils.LinkTarget.BLANK : linkService.externalLinkTarget,
-        rel: linkService.externalLinkRel,
-        enabled: linkService.externalLinkEnabled
-      });
-    } else if (data.action) {
-      this._bindNamedAction(link, data.action);
-    } else {
-      this._bindLink(link, data.dest);
+      if (data.url) {
+        (0, _display_utils.addLinkAttributes)(link, {
+          url: data.url,
+          target: data.newWindow ? _display_utils.LinkTarget.BLANK : linkService.externalLinkTarget,
+          rel: linkService.externalLinkRel,
+          enabled: linkService.externalLinkEnabled
+        });
+      } else if (data.action) {
+        this._bindNamedAction(link, data.action);
+      } else {
+        this._bindLink(link, data.dest);
+      }
+
+      this.container.appendChild(link);
+      return this.container;
     }
+  }, {
+    key: "_bindLink",
+    value: function _bindLink(link, destination) {
+      var _this = this;
 
-    this.container.appendChild(link);
-    return this.container;
-  }
+      link.href = this.linkService.getDestinationHash(destination);
+
+      link.onclick = function () {
+        if (destination) {
+          _this.linkService.navigateTo(destination);
+        }
 
-  _bindLink(link, destination) {
-    link.href = this.linkService.getDestinationHash(destination);
+        return false;
+      };
 
-    link.onclick = () => {
       if (destination) {
-        this.linkService.navigateTo(destination);
+        link.className = "internalLink";
       }
+    }
+  }, {
+    key: "_bindNamedAction",
+    value: function _bindNamedAction(link, action) {
+      var _this2 = this;
 
-      return false;
-    };
+      link.href = this.linkService.getAnchorUrl("");
+
+      link.onclick = function () {
+        _this2.linkService.executeNamedAction(action);
+
+        return false;
+      };
 
-    if (destination) {
       link.className = "internalLink";
     }
-  }
+  }]);
 
-  _bindNamedAction(link, action) {
-    link.href = this.linkService.getAnchorUrl("");
+  return LinkAnnotationElement;
+}(AnnotationElement);
 
-    link.onclick = () => {
-      this.linkService.executeNamedAction(action);
-      return false;
-    };
+var TextAnnotationElement = /*#__PURE__*/function (_AnnotationElement2) {
+  _inherits(TextAnnotationElement, _AnnotationElement2);
 
-    link.className = "internalLink";
+  var _super2 = _createSuper(TextAnnotationElement);
+
+  function TextAnnotationElement(parameters) {
+    _classCallCheck(this, TextAnnotationElement);
+
+    var isRenderable = !!(parameters.data.hasPopup || parameters.data.title || parameters.data.contents);
+    return _super2.call(this, parameters, isRenderable);
   }
 
-}
+  _createClass(TextAnnotationElement, [{
+    key: "render",
+    value: function render() {
+      this.container.className = "textAnnotation";
+      var image = document.createElement("img");
+      image.style.height = this.container.style.height;
+      image.style.width = this.container.style.width;
+      image.src = this.imageResourcesPath + "annotation-" + this.data.name.toLowerCase() + ".svg";
+      image.alt = "[{{type}} Annotation]";
+      image.dataset.l10nId = "text_annotation_type";
+      image.dataset.l10nArgs = JSON.stringify({
+        type: this.data.name
+      });
 
-class TextAnnotationElement extends AnnotationElement {
-  constructor(parameters) {
-    const isRenderable = !!(parameters.data.hasPopup || parameters.data.title || parameters.data.contents);
-    super(parameters, isRenderable);
-  }
-
-  render() {
-    this.container.className = "textAnnotation";
-    const image = document.createElement("img");
-    image.style.height = this.container.style.height;
-    image.style.width = this.container.style.width;
-    image.src = this.imageResourcesPath + "annotation-" + this.data.name.toLowerCase() + ".svg";
-    image.alt = "[{{type}} Annotation]";
-    image.dataset.l10nId = "text_annotation_type";
-    image.dataset.l10nArgs = JSON.stringify({
-      type: this.data.name
-    });
+      if (!this.data.hasPopup) {
+        this._createPopup(this.container, image, this.data);
+      }
 
-    if (!this.data.hasPopup) {
-      this._createPopup(this.container, image, this.data);
+      this.container.appendChild(image);
+      return this.container;
     }
+  }]);
 
-    this.container.appendChild(image);
-    return this.container;
-  }
+  return TextAnnotationElement;
+}(AnnotationElement);
 
-}
+var WidgetAnnotationElement = /*#__PURE__*/function (_AnnotationElement3) {
+  _inherits(WidgetAnnotationElement, _AnnotationElement3);
+
+  var _super3 = _createSuper(WidgetAnnotationElement);
 
-class WidgetAnnotationElement extends AnnotationElement {
-  render() {
-    return this.container;
+  function WidgetAnnotationElement() {
+    _classCallCheck(this, WidgetAnnotationElement);
+
+    return _super3.apply(this, arguments);
   }
 
-}
+  _createClass(WidgetAnnotationElement, [{
+    key: "render",
+    value: function render() {
+      return this.container;
+    }
+  }]);
+
+  return WidgetAnnotationElement;
+}(AnnotationElement);
 
-class TextWidgetAnnotationElement extends WidgetAnnotationElement {
-  constructor(parameters) {
-    const isRenderable = parameters.renderInteractiveForms || !parameters.data.hasAppearance && !!parameters.data.fieldValue;
-    super(parameters, isRenderable);
+var TextWidgetAnnotationElement = /*#__PURE__*/function (_WidgetAnnotationElem) {
+  _inherits(TextWidgetAnnotationElement, _WidgetAnnotationElem);
+
+  var _super4 = _createSuper(TextWidgetAnnotationElement);
+
+  function TextWidgetAnnotationElement(parameters) {
+    _classCallCheck(this, TextWidgetAnnotationElement);
+
+    var isRenderable = parameters.renderInteractiveForms || !parameters.data.hasAppearance && !!parameters.data.fieldValue;
+    return _super4.call(this, parameters, isRenderable);
   }
 
-  render() {
-    const TEXT_ALIGNMENT = ["left", "center", "right"];
-    this.container.className = "textWidgetAnnotation";
-    let element = null;
+  _createClass(TextWidgetAnnotationElement, [{
+    key: "render",
+    value: function render() {
+      var TEXT_ALIGNMENT = ["left", "center", "right"];
+      this.container.className = "textWidgetAnnotation";
+      var element = null;
 
-    if (this.renderInteractiveForms) {
-      if (this.data.multiLine) {
-        element = document.createElement("textarea");
-        element.textContent = this.data.fieldValue;
+      if (this.renderInteractiveForms) {
+        if (this.data.multiLine) {
+          element = document.createElement("textarea");
+          element.textContent = this.data.fieldValue;
+        } else {
+          element = document.createElement("input");
+          element.type = "text";
+          element.setAttribute("value", this.data.fieldValue);
+        }
+
+        element.disabled = this.data.readOnly;
+        element.name = this.data.fieldName;
+
+        if (this.data.maxLen !== null) {
+          element.maxLength = this.data.maxLen;
+        }
+
+        if (this.data.comb) {
+          var fieldWidth = this.data.rect[2] - this.data.rect[0];
+          var combWidth = fieldWidth / this.data.maxLen;
+          element.classList.add("comb");
+          element.style.letterSpacing = "calc(".concat(combWidth, "px - 1ch)");
+        }
       } else {
-        element = document.createElement("input");
-        element.type = "text";
-        element.setAttribute("value", this.data.fieldValue);
-      }
+        element = document.createElement("div");
+        element.textContent = this.data.fieldValue;
+        element.style.verticalAlign = "middle";
+        element.style.display = "table-cell";
+        var font = null;
 
-      element.disabled = this.data.readOnly;
-      element.name = this.data.fieldName;
+        if (this.data.fontRefName && this.page.commonObjs.has(this.data.fontRefName)) {
+          font = this.page.commonObjs.get(this.data.fontRefName);
+        }
 
-      if (this.data.maxLen !== null) {
-        element.maxLength = this.data.maxLen;
+        this._setTextStyle(element, font);
       }
 
-      if (this.data.comb) {
-        const fieldWidth = this.data.rect[2] - this.data.rect[0];
-        const combWidth = fieldWidth / this.data.maxLen;
-        element.classList.add("comb");
-        element.style.letterSpacing = `calc(${combWidth}px - 1ch)`;
+      if (this.data.textAlignment !== null) {
+        element.style.textAlign = TEXT_ALIGNMENT[this.data.textAlignment];
       }
-    } else {
-      element = document.createElement("div");
-      element.textContent = this.data.fieldValue;
-      element.style.verticalAlign = "middle";
-      element.style.display = "table-cell";
-      let font = null;
 
-      if (this.data.fontRefName && this.page.commonObjs.has(this.data.fontRefName)) {
-        font = this.page.commonObjs.get(this.data.fontRefName);
+      this.container.appendChild(element);
+      return this.container;
+    }
+  }, {
+    key: "_setTextStyle",
+    value: function _setTextStyle(element, font) {
+      var style = element.style;
+      style.fontSize = "".concat(this.data.fontSize, "px");
+      style.direction = this.data.fontDirection < 0 ? "rtl" : "ltr";
+
+      if (!font) {
+        return;
+      }
+
+      var bold = "normal";
+
+      if (font.black) {
+        bold = "900";
+      } else if (font.bold) {
+        bold = "bold";
       }
 
-      this._setTextStyle(element, font);
+      style.fontWeight = bold;
+      style.fontStyle = font.italic ? "italic" : "normal";
+      var fontFamily = font.loadedName ? "\"".concat(font.loadedName, "\", ") : "";
+      var fallbackName = font.fallbackName || "Helvetica, sans-serif";
+      style.fontFamily = fontFamily + fallbackName;
     }
+  }]);
 
-    if (this.data.textAlignment !== null) {
-      element.style.textAlign = TEXT_ALIGNMENT[this.data.textAlignment];
-    }
+  return TextWidgetAnnotationElement;
+}(WidgetAnnotationElement);
 
-    this.container.appendChild(element);
-    return this.container;
+var CheckboxWidgetAnnotationElement = /*#__PURE__*/function (_WidgetAnnotationElem2) {
+  _inherits(CheckboxWidgetAnnotationElement, _WidgetAnnotationElem2);
+
+  var _super5 = _createSuper(CheckboxWidgetAnnotationElement);
+
+  function CheckboxWidgetAnnotationElement(parameters) {
+    _classCallCheck(this, CheckboxWidgetAnnotationElement);
+
+    return _super5.call(this, parameters, parameters.renderInteractiveForms);
   }
 
-  _setTextStyle(element, font) {
-    const style = element.style;
-    style.fontSize = `${this.data.fontSize}px`;
-    style.direction = this.data.fontDirection < 0 ? "rtl" : "ltr";
+  _createClass(CheckboxWidgetAnnotationElement, [{
+    key: "render",
+    value: function render() {
+      this.container.className = "buttonWidgetAnnotation checkBox";
+      var element = document.createElement("input");
+      element.disabled = this.data.readOnly;
+      element.type = "checkbox";
+      element.name = this.data.fieldName;
 
-    if (!font) {
-      return;
+      if (this.data.fieldValue && this.data.fieldValue !== "Off") {
+        element.setAttribute("checked", true);
+      }
+
+      this.container.appendChild(element);
+      return this.container;
     }
+  }]);
 
-    let bold = "normal";
+  return CheckboxWidgetAnnotationElement;
+}(WidgetAnnotationElement);
 
-    if (font.black) {
-      bold = "900";
-    } else if (font.bold) {
-      bold = "bold";
-    }
+var RadioButtonWidgetAnnotationElement = /*#__PURE__*/function (_WidgetAnnotationElem3) {
+  _inherits(RadioButtonWidgetAnnotationElement, _WidgetAnnotationElem3);
 
-    style.fontWeight = bold;
-    style.fontStyle = font.italic ? "italic" : "normal";
-    const fontFamily = font.loadedName ? `"${font.loadedName}", ` : "";
-    const fallbackName = font.fallbackName || "Helvetica, sans-serif";
-    style.fontFamily = fontFamily + fallbackName;
-  }
+  var _super6 = _createSuper(RadioButtonWidgetAnnotationElement);
 
-}
+  function RadioButtonWidgetAnnotationElement(parameters) {
+    _classCallCheck(this, RadioButtonWidgetAnnotationElement);
 
-class CheckboxWidgetAnnotationElement extends WidgetAnnotationElement {
-  constructor(parameters) {
-    super(parameters, parameters.renderInteractiveForms);
+    return _super6.call(this, parameters, parameters.renderInteractiveForms);
   }
 
-  render() {
-    this.container.className = "buttonWidgetAnnotation checkBox";
-    const element = document.createElement("input");
-    element.disabled = this.data.readOnly;
-    element.type = "checkbox";
-    element.name = this.data.fieldName;
+  _createClass(RadioButtonWidgetAnnotationElement, [{
+    key: "render",
+    value: function render() {
+      this.container.className = "buttonWidgetAnnotation radioButton";
+      var element = document.createElement("input");
+      element.disabled = this.data.readOnly;
+      element.type = "radio";
+      element.name = this.data.fieldName;
 
-    if (this.data.fieldValue && this.data.fieldValue !== "Off") {
-      element.setAttribute("checked", true);
+      if (this.data.fieldValue === this.data.buttonValue) {
+        element.setAttribute("checked", true);
+      }
+
+      this.container.appendChild(element);
+      return this.container;
     }
+  }]);
 
-    this.container.appendChild(element);
-    return this.container;
-  }
+  return RadioButtonWidgetAnnotationElement;
+}(WidgetAnnotationElement);
 
-}
+var PushButtonWidgetAnnotationElement = /*#__PURE__*/function (_LinkAnnotationElemen) {
+  _inherits(PushButtonWidgetAnnotationElement, _LinkAnnotationElemen);
+
+  var _super7 = _createSuper(PushButtonWidgetAnnotationElement);
+
+  function PushButtonWidgetAnnotationElement() {
+    _classCallCheck(this, PushButtonWidgetAnnotationElement);
 
-class RadioButtonWidgetAnnotationElement extends WidgetAnnotationElement {
-  constructor(parameters) {
-    super(parameters, parameters.renderInteractiveForms);
+    return _super7.apply(this, arguments);
   }
 
-  render() {
-    this.container.className = "buttonWidgetAnnotation radioButton";
-    const element = document.createElement("input");
-    element.disabled = this.data.readOnly;
-    element.type = "radio";
-    element.name = this.data.fieldName;
+  _createClass(PushButtonWidgetAnnotationElement, [{
+    key: "render",
+    value: function render() {
+      var container = _get(_getPrototypeOf(PushButtonWidgetAnnotationElement.prototype), "render", this).call(this);
 
-    if (this.data.fieldValue === this.data.buttonValue) {
-      element.setAttribute("checked", true);
+      container.className = "buttonWidgetAnnotation pushButton";
+      return container;
     }
+  }]);
 
-    this.container.appendChild(element);
-    return this.container;
-  }
+  return PushButtonWidgetAnnotationElement;
+}(LinkAnnotationElement);
 
-}
+var ChoiceWidgetAnnotationElement = /*#__PURE__*/function (_WidgetAnnotationElem4) {
+  _inherits(ChoiceWidgetAnnotationElement, _WidgetAnnotationElem4);
 
-class PushButtonWidgetAnnotationElement extends LinkAnnotationElement {
-  render() {
-    const container = super.render();
-    container.className = "buttonWidgetAnnotation pushButton";
-    return container;
-  }
+  var _super8 = _createSuper(ChoiceWidgetAnnotationElement);
 
-}
+  function ChoiceWidgetAnnotationElement(parameters) {
+    _classCallCheck(this, ChoiceWidgetAnnotationElement);
 
-class ChoiceWidgetAnnotationElement extends WidgetAnnotationElement {
-  constructor(parameters) {
-    super(parameters, parameters.renderInteractiveForms);
+    return _super8.call(this, parameters, parameters.renderInteractiveForms);
   }
 
-  render() {
-    this.container.className = "choiceWidgetAnnotation";
-    const selectElement = document.createElement("select");
-    selectElement.disabled = this.data.readOnly;
-    selectElement.name = this.data.fieldName;
+  _createClass(ChoiceWidgetAnnotationElement, [{
+    key: "render",
+    value: function render() {
+      this.container.className = "choiceWidgetAnnotation";
+      var selectElement = document.createElement("select");
+      selectElement.disabled = this.data.readOnly;
+      selectElement.name = this.data.fieldName;
 
-    if (!this.data.combo) {
-      selectElement.size = this.data.options.length;
+      if (!this.data.combo) {
+        selectElement.size = this.data.options.length;
 
-      if (this.data.multiSelect) {
-        selectElement.multiple = true;
+        if (this.data.multiSelect) {
+          selectElement.multiple = true;
+        }
       }
-    }
 
-    for (const option of this.data.options) {
-      const optionElement = document.createElement("option");
-      optionElement.textContent = option.displayValue;
-      optionElement.value = option.exportValue;
+      var _iterator = _createForOfIteratorHelper(this.data.options),
+          _step;
 
-      if (this.data.fieldValue.includes(option.displayValue)) {
-        optionElement.setAttribute("selected", true);
+      try {
+        for (_iterator.s(); !(_step = _iterator.n()).done;) {
+          var option = _step.value;
+          var optionElement = document.createElement("option");
+          optionElement.textContent = option.displayValue;
+          optionElement.value = option.exportValue;
+
+          if (this.data.fieldValue.includes(option.displayValue)) {
+            optionElement.setAttribute("selected", true);
+          }
+
+          selectElement.appendChild(optionElement);
+        }
+      } catch (err) {
+        _iterator.e(err);
+      } finally {
+        _iterator.f();
       }
 
-      selectElement.appendChild(optionElement);
+      this.container.appendChild(selectElement);
+      return this.container;
     }
+  }]);
 
-    this.container.appendChild(selectElement);
-    return this.container;
-  }
+  return ChoiceWidgetAnnotationElement;
+}(WidgetAnnotationElement);
 
-}
+var PopupAnnotationElement = /*#__PURE__*/function (_AnnotationElement4) {
+  _inherits(PopupAnnotationElement, _AnnotationElement4);
+
+  var _super9 = _createSuper(PopupAnnotationElement);
+
+  function PopupAnnotationElement(parameters) {
+    _classCallCheck(this, PopupAnnotationElement);
 
-class PopupAnnotationElement extends AnnotationElement {
-  constructor(parameters) {
-    const isRenderable = !!(parameters.data.title || parameters.data.contents);
-    super(parameters, isRenderable);
+    var isRenderable = !!(parameters.data.title || parameters.data.contents);
+    return _super9.call(this, parameters, isRenderable);
   }
 
-  render() {
-    const IGNORE_TYPES = ["Line", "Square", "Circle", "PolyLine", "Polygon", "Ink"];
-    this.container.className = "popupAnnotation";
+  _createClass(PopupAnnotationElement, [{
+    key: "render",
+    value: function render() {
+      var IGNORE_TYPES = ["Line", "Square", "Circle", "PolyLine", "Polygon", "Ink"];
+      this.container.className = "popupAnnotation";
 
-    if (IGNORE_TYPES.includes(this.data.parentType)) {
-      return this.container;
-    }
+      if (IGNORE_TYPES.includes(this.data.parentType)) {
+        return this.container;
+      }
 
-    const selector = `[data-annotation-id="${this.data.parentId}"]`;
-    const parentElement = this.layer.querySelector(selector);
+      var selector = "[data-annotation-id=\"".concat(this.data.parentId, "\"]");
+      var parentElement = this.layer.querySelector(selector);
 
-    if (!parentElement) {
+      if (!parentElement) {
+        return this.container;
+      }
+
+      var popup = new PopupElement({
+        container: this.container,
+        trigger: parentElement,
+        color: this.data.color,
+        title: this.data.title,
+        modificationDate: this.data.modificationDate,
+        contents: this.data.contents
+      });
+      var parentLeft = parseFloat(parentElement.style.left);
+      var parentWidth = parseFloat(parentElement.style.width);
+      this.container.style.transformOrigin = "-".concat(parentLeft + parentWidth, "px -").concat(parentElement.style.top);
+      this.container.style.left = "".concat(parentLeft + parentWidth, "px");
+      this.container.appendChild(popup.render());
       return this.container;
     }
+  }]);
 
-    const popup = new PopupElement({
-      container: this.container,
-      trigger: parentElement,
-      color: this.data.color,
-      title: this.data.title,
-      modificationDate: this.data.modificationDate,
-      contents: this.data.contents
-    });
-    const parentLeft = parseFloat(parentElement.style.left);
-    const parentWidth = parseFloat(parentElement.style.width);
-    this.container.style.transformOrigin = `-${parentLeft + parentWidth}px -${parentElement.style.top}`;
-    this.container.style.left = `${parentLeft + parentWidth}px`;
-    this.container.appendChild(popup.render());
-    return this.container;
-  }
+  return PopupAnnotationElement;
+}(AnnotationElement);
 
-}
+var PopupElement = /*#__PURE__*/function () {
+  function PopupElement(parameters) {
+    _classCallCheck(this, PopupElement);
 
-class PopupElement {
-  constructor(parameters) {
     this.container = parameters.container;
     this.trigger = parameters.trigger;
     this.color = parameters.color;
@@ -9166,510 +20502,733 @@ class PopupElement {
     this.pinned = false;
   }
 
-  render() {
-    const BACKGROUND_ENLIGHT = 0.7;
-    const wrapper = document.createElement("div");
-    wrapper.className = "popupWrapper";
-    this.hideElement = this.hideWrapper ? wrapper : this.container;
-    this.hideElement.setAttribute("hidden", true);
-    const popup = document.createElement("div");
-    popup.className = "popup";
-    const color = this.color;
-
-    if (color) {
-      const r = BACKGROUND_ENLIGHT * (255 - color[0]) + color[0];
-      const g = BACKGROUND_ENLIGHT * (255 - color[1]) + color[1];
-      const b = BACKGROUND_ENLIGHT * (255 - color[2]) + color[2];
-      popup.style.backgroundColor = _util.Util.makeCssRgb(r | 0, g | 0, b | 0);
-    }
-
-    const title = document.createElement("h1");
-    title.textContent = this.title;
-    popup.appendChild(title);
-
-    const dateObject = _display_utils.PDFDateString.toDateObject(this.modificationDate);
-
-    if (dateObject) {
-      const modificationDate = document.createElement("span");
-      modificationDate.textContent = "{{date}}, {{time}}";
-      modificationDate.dataset.l10nId = "annotation_date_string";
-      modificationDate.dataset.l10nArgs = JSON.stringify({
-        date: dateObject.toLocaleDateString(),
-        time: dateObject.toLocaleTimeString()
-      });
-      popup.appendChild(modificationDate);
-    }
-
-    const contents = this._formatContents(this.contents);
+  _createClass(PopupElement, [{
+    key: "render",
+    value: function render() {
+      var BACKGROUND_ENLIGHT = 0.7;
+      var wrapper = document.createElement("div");
+      wrapper.className = "popupWrapper";
+      this.hideElement = this.hideWrapper ? wrapper : this.container;
+      this.hideElement.setAttribute("hidden", true);
+      var popup = document.createElement("div");
+      popup.className = "popup";
+      var color = this.color;
 
-    popup.appendChild(contents);
-    this.trigger.addEventListener("click", this._toggle.bind(this));
-    this.trigger.addEventListener("mouseover", this._show.bind(this, false));
-    this.trigger.addEventListener("mouseout", this._hide.bind(this, false));
-    popup.addEventListener("click", this._hide.bind(this, true));
-    wrapper.appendChild(popup);
-    return wrapper;
-  }
+      if (color) {
+        var r = BACKGROUND_ENLIGHT * (255 - color[0]) + color[0];
+        var g = BACKGROUND_ENLIGHT * (255 - color[1]) + color[1];
+        var b = BACKGROUND_ENLIGHT * (255 - color[2]) + color[2];
+        popup.style.backgroundColor = _util.Util.makeCssRgb(r | 0, g | 0, b | 0);
+      }
 
-  _formatContents(contents) {
-    const p = document.createElement("p");
-    const lines = contents.split(/(?:\r\n?|\n)/);
+      var title = document.createElement("h1");
+      title.textContent = this.title;
+      popup.appendChild(title);
 
-    for (let i = 0, ii = lines.length; i < ii; ++i) {
-      const line = lines[i];
-      p.appendChild(document.createTextNode(line));
+      var dateObject = _display_utils.PDFDateString.toDateObject(this.modificationDate);
 
-      if (i < ii - 1) {
-        p.appendChild(document.createElement("br"));
+      if (dateObject) {
+        var modificationDate = document.createElement("span");
+        modificationDate.textContent = "{{date}}, {{time}}";
+        modificationDate.dataset.l10nId = "annotation_date_string";
+        modificationDate.dataset.l10nArgs = JSON.stringify({
+          date: dateObject.toLocaleDateString(),
+          time: dateObject.toLocaleTimeString()
+        });
+        popup.appendChild(modificationDate);
       }
-    }
 
-    return p;
-  }
+      var contents = this._formatContents(this.contents);
 
-  _toggle() {
-    if (this.pinned) {
-      this._hide(true);
-    } else {
-      this._show(true);
+      popup.appendChild(contents);
+      this.trigger.addEventListener("click", this._toggle.bind(this));
+      this.trigger.addEventListener("mouseover", this._show.bind(this, false));
+      this.trigger.addEventListener("mouseout", this._hide.bind(this, false));
+      popup.addEventListener("click", this._hide.bind(this, true));
+      wrapper.appendChild(popup);
+      return wrapper;
     }
-  }
+  }, {
+    key: "_formatContents",
+    value: function _formatContents(contents) {
+      var p = document.createElement("p");
+      var lines = contents.split(/(?:\r\n?|\n)/);
 
-  _show(pin = false) {
-    if (pin) {
-      this.pinned = true;
-    }
+      for (var i = 0, ii = lines.length; i < ii; ++i) {
+        var line = lines[i];
+        p.appendChild(document.createTextNode(line));
 
-    if (this.hideElement.hasAttribute("hidden")) {
-      this.hideElement.removeAttribute("hidden");
-      this.container.style.zIndex += 1;
-    }
-  }
+        if (i < ii - 1) {
+          p.appendChild(document.createElement("br"));
+        }
+      }
 
-  _hide(unpin = true) {
-    if (unpin) {
-      this.pinned = false;
+      return p;
     }
-
-    if (!this.hideElement.hasAttribute("hidden") && !this.pinned) {
-      this.hideElement.setAttribute("hidden", true);
-      this.container.style.zIndex -= 1;
+  }, {
+    key: "_toggle",
+    value: function _toggle() {
+      if (this.pinned) {
+        this._hide(true);
+      } else {
+        this._show(true);
+      }
     }
-  }
+  }, {
+    key: "_show",
+    value: function _show() {
+      var pin = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : false;
 
-}
+      if (pin) {
+        this.pinned = true;
+      }
 
-class FreeTextAnnotationElement extends AnnotationElement {
-  constructor(parameters) {
-    const isRenderable = !!(parameters.data.hasPopup || parameters.data.title || parameters.data.contents);
-    super(parameters, isRenderable, true);
-  }
+      if (this.hideElement.hasAttribute("hidden")) {
+        this.hideElement.removeAttribute("hidden");
+        this.container.style.zIndex += 1;
+      }
+    }
+  }, {
+    key: "_hide",
+    value: function _hide() {
+      var unpin = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : true;
 
-  render() {
-    this.container.className = "freeTextAnnotation";
+      if (unpin) {
+        this.pinned = false;
+      }
 
-    if (!this.data.hasPopup) {
-      this._createPopup(this.container, null, this.data);
+      if (!this.hideElement.hasAttribute("hidden") && !this.pinned) {
+        this.hideElement.setAttribute("hidden", true);
+        this.container.style.zIndex -= 1;
+      }
     }
+  }]);
 
-    return this.container;
-  }
+  return PopupElement;
+}();
 
-}
+var FreeTextAnnotationElement = /*#__PURE__*/function (_AnnotationElement5) {
+  _inherits(FreeTextAnnotationElement, _AnnotationElement5);
+
+  var _super10 = _createSuper(FreeTextAnnotationElement);
 
-class LineAnnotationElement extends AnnotationElement {
-  constructor(parameters) {
-    const isRenderable = !!(parameters.data.hasPopup || parameters.data.title || parameters.data.contents);
-    super(parameters, isRenderable, true);
+  function FreeTextAnnotationElement(parameters) {
+    _classCallCheck(this, FreeTextAnnotationElement);
+
+    var isRenderable = !!(parameters.data.hasPopup || parameters.data.title || parameters.data.contents);
+    return _super10.call(this, parameters, isRenderable, true);
   }
 
-  render() {
-    this.container.className = "lineAnnotation";
-    const data = this.data;
-    const width = data.rect[2] - data.rect[0];
-    const height = data.rect[3] - data.rect[1];
-    const svg = this.svgFactory.create(width, height);
-    const line = this.svgFactory.createElement("svg:line");
-    line.setAttribute("x1", data.rect[2] - data.lineCoordinates[0]);
-    line.setAttribute("y1", data.rect[3] - data.lineCoordinates[1]);
-    line.setAttribute("x2", data.rect[2] - data.lineCoordinates[2]);
-    line.setAttribute("y2", data.rect[3] - data.lineCoordinates[3]);
-    line.setAttribute("stroke-width", data.borderStyle.width || 1);
-    line.setAttribute("stroke", "transparent");
-    svg.appendChild(line);
-    this.container.append(svg);
+  _createClass(FreeTextAnnotationElement, [{
+    key: "render",
+    value: function render() {
+      this.container.className = "freeTextAnnotation";
 
-    this._createPopup(this.container, line, data);
+      if (!this.data.hasPopup) {
+        this._createPopup(this.container, null, this.data);
+      }
 
-    return this.container;
-  }
+      return this.container;
+    }
+  }]);
 
-}
+  return FreeTextAnnotationElement;
+}(AnnotationElement);
 
-class SquareAnnotationElement extends AnnotationElement {
-  constructor(parameters) {
-    const isRenderable = !!(parameters.data.hasPopup || parameters.data.title || parameters.data.contents);
-    super(parameters, isRenderable, true);
-  }
+var LineAnnotationElement = /*#__PURE__*/function (_AnnotationElement6) {
+  _inherits(LineAnnotationElement, _AnnotationElement6);
 
-  render() {
-    this.container.className = "squareAnnotation";
-    const data = this.data;
-    const width = data.rect[2] - data.rect[0];
-    const height = data.rect[3] - data.rect[1];
-    const svg = this.svgFactory.create(width, height);
-    const borderWidth = data.borderStyle.width;
-    const square = this.svgFactory.createElement("svg:rect");
-    square.setAttribute("x", borderWidth / 2);
-    square.setAttribute("y", borderWidth / 2);
-    square.setAttribute("width", width - borderWidth);
-    square.setAttribute("height", height - borderWidth);
-    square.setAttribute("stroke-width", borderWidth || 1);
-    square.setAttribute("stroke", "transparent");
-    square.setAttribute("fill", "none");
-    svg.appendChild(square);
-    this.container.append(svg);
+  var _super11 = _createSuper(LineAnnotationElement);
 
-    this._createPopup(this.container, square, data);
+  function LineAnnotationElement(parameters) {
+    _classCallCheck(this, LineAnnotationElement);
 
-    return this.container;
+    var isRenderable = !!(parameters.data.hasPopup || parameters.data.title || parameters.data.contents);
+    return _super11.call(this, parameters, isRenderable, true);
   }
 
-}
+  _createClass(LineAnnotationElement, [{
+    key: "render",
+    value: function render() {
+      this.container.className = "lineAnnotation";
+      var data = this.data;
+      var width = data.rect[2] - data.rect[0];
+      var height = data.rect[3] - data.rect[1];
+      var svg = this.svgFactory.create(width, height);
+      var line = this.svgFactory.createElement("svg:line");
+      line.setAttribute("x1", data.rect[2] - data.lineCoordinates[0]);
+      line.setAttribute("y1", data.rect[3] - data.lineCoordinates[1]);
+      line.setAttribute("x2", data.rect[2] - data.lineCoordinates[2]);
+      line.setAttribute("y2", data.rect[3] - data.lineCoordinates[3]);
+      line.setAttribute("stroke-width", data.borderStyle.width || 1);
+      line.setAttribute("stroke", "transparent");
+      svg.appendChild(line);
+      this.container.append(svg);
 
-class CircleAnnotationElement extends AnnotationElement {
-  constructor(parameters) {
-    const isRenderable = !!(parameters.data.hasPopup || parameters.data.title || parameters.data.contents);
-    super(parameters, isRenderable, true);
-  }
+      this._createPopup(this.container, line, data);
+
+      return this.container;
+    }
+  }]);
 
-  render() {
-    this.container.className = "circleAnnotation";
-    const data = this.data;
-    const width = data.rect[2] - data.rect[0];
-    const height = data.rect[3] - data.rect[1];
-    const svg = this.svgFactory.create(width, height);
-    const borderWidth = data.borderStyle.width;
-    const circle = this.svgFactory.createElement("svg:ellipse");
-    circle.setAttribute("cx", width / 2);
-    circle.setAttribute("cy", height / 2);
-    circle.setAttribute("rx", width / 2 - borderWidth / 2);
-    circle.setAttribute("ry", height / 2 - borderWidth / 2);
-    circle.setAttribute("stroke-width", borderWidth || 1);
-    circle.setAttribute("stroke", "transparent");
-    circle.setAttribute("fill", "none");
-    svg.appendChild(circle);
-    this.container.append(svg);
+  return LineAnnotationElement;
+}(AnnotationElement);
 
-    this._createPopup(this.container, circle, data);
+var SquareAnnotationElement = /*#__PURE__*/function (_AnnotationElement7) {
+  _inherits(SquareAnnotationElement, _AnnotationElement7);
 
-    return this.container;
-  }
+  var _super12 = _createSuper(SquareAnnotationElement);
 
-}
+  function SquareAnnotationElement(parameters) {
+    _classCallCheck(this, SquareAnnotationElement);
 
-class PolylineAnnotationElement extends AnnotationElement {
-  constructor(parameters) {
-    const isRenderable = !!(parameters.data.hasPopup || parameters.data.title || parameters.data.contents);
-    super(parameters, isRenderable, true);
-    this.containerClassName = "polylineAnnotation";
-    this.svgElementName = "svg:polyline";
+    var isRenderable = !!(parameters.data.hasPopup || parameters.data.title || parameters.data.contents);
+    return _super12.call(this, parameters, isRenderable, true);
   }
 
-  render() {
-    this.container.className = this.containerClassName;
-    const data = this.data;
-    const width = data.rect[2] - data.rect[0];
-    const height = data.rect[3] - data.rect[1];
-    const svg = this.svgFactory.create(width, height);
-    let points = [];
+  _createClass(SquareAnnotationElement, [{
+    key: "render",
+    value: function render() {
+      this.container.className = "squareAnnotation";
+      var data = this.data;
+      var width = data.rect[2] - data.rect[0];
+      var height = data.rect[3] - data.rect[1];
+      var svg = this.svgFactory.create(width, height);
+      var borderWidth = data.borderStyle.width;
+      var square = this.svgFactory.createElement("svg:rect");
+      square.setAttribute("x", borderWidth / 2);
+      square.setAttribute("y", borderWidth / 2);
+      square.setAttribute("width", width - borderWidth);
+      square.setAttribute("height", height - borderWidth);
+      square.setAttribute("stroke-width", borderWidth || 1);
+      square.setAttribute("stroke", "transparent");
+      square.setAttribute("fill", "none");
+      svg.appendChild(square);
+      this.container.append(svg);
+
+      this._createPopup(this.container, square, data);
 
-    for (const coordinate of data.vertices) {
-      const x = coordinate.x - data.rect[0];
-      const y = data.rect[3] - coordinate.y;
-      points.push(x + "," + y);
+      return this.container;
     }
+  }]);
 
-    points = points.join(" ");
-    const polyline = this.svgFactory.createElement(this.svgElementName);
-    polyline.setAttribute("points", points);
-    polyline.setAttribute("stroke-width", data.borderStyle.width || 1);
-    polyline.setAttribute("stroke", "transparent");
-    polyline.setAttribute("fill", "none");
-    svg.appendChild(polyline);
-    this.container.append(svg);
+  return SquareAnnotationElement;
+}(AnnotationElement);
 
-    this._createPopup(this.container, polyline, data);
+var CircleAnnotationElement = /*#__PURE__*/function (_AnnotationElement8) {
+  _inherits(CircleAnnotationElement, _AnnotationElement8);
 
-    return this.container;
-  }
+  var _super13 = _createSuper(CircleAnnotationElement);
 
-}
+  function CircleAnnotationElement(parameters) {
+    _classCallCheck(this, CircleAnnotationElement);
 
-class PolygonAnnotationElement extends PolylineAnnotationElement {
-  constructor(parameters) {
-    super(parameters);
-    this.containerClassName = "polygonAnnotation";
-    this.svgElementName = "svg:polygon";
+    var isRenderable = !!(parameters.data.hasPopup || parameters.data.title || parameters.data.contents);
+    return _super13.call(this, parameters, isRenderable, true);
   }
 
-}
-
-class CaretAnnotationElement extends AnnotationElement {
-  constructor(parameters) {
-    const isRenderable = !!(parameters.data.hasPopup || parameters.data.title || parameters.data.contents);
-    super(parameters, isRenderable, true);
-  }
+  _createClass(CircleAnnotationElement, [{
+    key: "render",
+    value: function render() {
+      this.container.className = "circleAnnotation";
+      var data = this.data;
+      var width = data.rect[2] - data.rect[0];
+      var height = data.rect[3] - data.rect[1];
+      var svg = this.svgFactory.create(width, height);
+      var borderWidth = data.borderStyle.width;
+      var circle = this.svgFactory.createElement("svg:ellipse");
+      circle.setAttribute("cx", width / 2);
+      circle.setAttribute("cy", height / 2);
+      circle.setAttribute("rx", width / 2 - borderWidth / 2);
+      circle.setAttribute("ry", height / 2 - borderWidth / 2);
+      circle.setAttribute("stroke-width", borderWidth || 1);
+      circle.setAttribute("stroke", "transparent");
+      circle.setAttribute("fill", "none");
+      svg.appendChild(circle);
+      this.container.append(svg);
 
-  render() {
-    this.container.className = "caretAnnotation";
+      this._createPopup(this.container, circle, data);
 
-    if (!this.data.hasPopup) {
-      this._createPopup(this.container, null, this.data);
+      return this.container;
     }
+  }]);
 
-    return this.container;
-  }
+  return CircleAnnotationElement;
+}(AnnotationElement);
 
-}
+var PolylineAnnotationElement = /*#__PURE__*/function (_AnnotationElement9) {
+  _inherits(PolylineAnnotationElement, _AnnotationElement9);
+
+  var _super14 = _createSuper(PolylineAnnotationElement);
+
+  function PolylineAnnotationElement(parameters) {
+    var _this3;
 
-class InkAnnotationElement extends AnnotationElement {
-  constructor(parameters) {
-    const isRenderable = !!(parameters.data.hasPopup || parameters.data.title || parameters.data.contents);
-    super(parameters, isRenderable, true);
-    this.containerClassName = "inkAnnotation";
-    this.svgElementName = "svg:polyline";
+    _classCallCheck(this, PolylineAnnotationElement);
+
+    var isRenderable = !!(parameters.data.hasPopup || parameters.data.title || parameters.data.contents);
+    _this3 = _super14.call(this, parameters, isRenderable, true);
+    _this3.containerClassName = "polylineAnnotation";
+    _this3.svgElementName = "svg:polyline";
+    return _this3;
   }
 
-  render() {
-    this.container.className = this.containerClassName;
-    const data = this.data;
-    const width = data.rect[2] - data.rect[0];
-    const height = data.rect[3] - data.rect[1];
-    const svg = this.svgFactory.create(width, height);
+  _createClass(PolylineAnnotationElement, [{
+    key: "render",
+    value: function render() {
+      this.container.className = this.containerClassName;
+      var data = this.data;
+      var width = data.rect[2] - data.rect[0];
+      var height = data.rect[3] - data.rect[1];
+      var svg = this.svgFactory.create(width, height);
+      var points = [];
 
-    for (const inkList of data.inkLists) {
-      let points = [];
+      var _iterator2 = _createForOfIteratorHelper(data.vertices),
+          _step2;
 
-      for (const coordinate of inkList) {
-        const x = coordinate.x - data.rect[0];
-        const y = data.rect[3] - coordinate.y;
-        points.push(`${x},${y}`);
+      try {
+        for (_iterator2.s(); !(_step2 = _iterator2.n()).done;) {
+          var coordinate = _step2.value;
+          var x = coordinate.x - data.rect[0];
+          var y = data.rect[3] - coordinate.y;
+          points.push(x + "," + y);
+        }
+      } catch (err) {
+        _iterator2.e(err);
+      } finally {
+        _iterator2.f();
       }
 
       points = points.join(" ");
-      const polyline = this.svgFactory.createElement(this.svgElementName);
+      var polyline = this.svgFactory.createElement(this.svgElementName);
       polyline.setAttribute("points", points);
       polyline.setAttribute("stroke-width", data.borderStyle.width || 1);
       polyline.setAttribute("stroke", "transparent");
       polyline.setAttribute("fill", "none");
+      svg.appendChild(polyline);
+      this.container.append(svg);
 
       this._createPopup(this.container, polyline, data);
 
-      svg.appendChild(polyline);
+      return this.container;
     }
+  }]);
+
+  return PolylineAnnotationElement;
+}(AnnotationElement);
+
+var PolygonAnnotationElement = /*#__PURE__*/function (_PolylineAnnotationEl) {
+  _inherits(PolygonAnnotationElement, _PolylineAnnotationEl);
+
+  var _super15 = _createSuper(PolygonAnnotationElement);
+
+  function PolygonAnnotationElement(parameters) {
+    var _this4;
 
-    this.container.append(svg);
-    return this.container;
+    _classCallCheck(this, PolygonAnnotationElement);
+
+    _this4 = _super15.call(this, parameters);
+    _this4.containerClassName = "polygonAnnotation";
+    _this4.svgElementName = "svg:polygon";
+    return _this4;
   }
 
-}
+  return PolygonAnnotationElement;
+}(PolylineAnnotationElement);
+
+var CaretAnnotationElement = /*#__PURE__*/function (_AnnotationElement10) {
+  _inherits(CaretAnnotationElement, _AnnotationElement10);
+
+  var _super16 = _createSuper(CaretAnnotationElement);
+
+  function CaretAnnotationElement(parameters) {
+    _classCallCheck(this, CaretAnnotationElement);
 
-class HighlightAnnotationElement extends AnnotationElement {
-  constructor(parameters) {
-    const isRenderable = !!(parameters.data.hasPopup || parameters.data.title || parameters.data.contents);
-    super(parameters, isRenderable, true);
+    var isRenderable = !!(parameters.data.hasPopup || parameters.data.title || parameters.data.contents);
+    return _super16.call(this, parameters, isRenderable, true);
   }
 
-  render() {
-    this.container.className = "highlightAnnotation";
+  _createClass(CaretAnnotationElement, [{
+    key: "render",
+    value: function render() {
+      this.container.className = "caretAnnotation";
 
-    if (!this.data.hasPopup) {
-      this._createPopup(this.container, null, this.data);
+      if (!this.data.hasPopup) {
+        this._createPopup(this.container, null, this.data);
+      }
+
+      return this.container;
     }
+  }]);
 
-    return this.container;
-  }
+  return CaretAnnotationElement;
+}(AnnotationElement);
 
-}
+var InkAnnotationElement = /*#__PURE__*/function (_AnnotationElement11) {
+  _inherits(InkAnnotationElement, _AnnotationElement11);
+
+  var _super17 = _createSuper(InkAnnotationElement);
 
-class UnderlineAnnotationElement extends AnnotationElement {
-  constructor(parameters) {
-    const isRenderable = !!(parameters.data.hasPopup || parameters.data.title || parameters.data.contents);
-    super(parameters, isRenderable, true);
+  function InkAnnotationElement(parameters) {
+    var _this5;
+
+    _classCallCheck(this, InkAnnotationElement);
+
+    var isRenderable = !!(parameters.data.hasPopup || parameters.data.title || parameters.data.contents);
+    _this5 = _super17.call(this, parameters, isRenderable, true);
+    _this5.containerClassName = "inkAnnotation";
+    _this5.svgElementName = "svg:polyline";
+    return _this5;
   }
 
-  render() {
-    this.container.className = "underlineAnnotation";
+  _createClass(InkAnnotationElement, [{
+    key: "render",
+    value: function render() {
+      this.container.className = this.containerClassName;
+      var data = this.data;
+      var width = data.rect[2] - data.rect[0];
+      var height = data.rect[3] - data.rect[1];
+      var svg = this.svgFactory.create(width, height);
+
+      var _iterator3 = _createForOfIteratorHelper(data.inkLists),
+          _step3;
+
+      try {
+        for (_iterator3.s(); !(_step3 = _iterator3.n()).done;) {
+          var inkList = _step3.value;
+          var points = [];
+
+          var _iterator4 = _createForOfIteratorHelper(inkList),
+              _step4;
+
+          try {
+            for (_iterator4.s(); !(_step4 = _iterator4.n()).done;) {
+              var coordinate = _step4.value;
+              var x = coordinate.x - data.rect[0];
+              var y = data.rect[3] - coordinate.y;
+              points.push("".concat(x, ",").concat(y));
+            }
+          } catch (err) {
+            _iterator4.e(err);
+          } finally {
+            _iterator4.f();
+          }
+
+          points = points.join(" ");
+          var polyline = this.svgFactory.createElement(this.svgElementName);
+          polyline.setAttribute("points", points);
+          polyline.setAttribute("stroke-width", data.borderStyle.width || 1);
+          polyline.setAttribute("stroke", "transparent");
+          polyline.setAttribute("fill", "none");
+
+          this._createPopup(this.container, polyline, data);
+
+          svg.appendChild(polyline);
+        }
+      } catch (err) {
+        _iterator3.e(err);
+      } finally {
+        _iterator3.f();
+      }
 
-    if (!this.data.hasPopup) {
-      this._createPopup(this.container, null, this.data);
+      this.container.append(svg);
+      return this.container;
     }
+  }]);
 
-    return this.container;
-  }
+  return InkAnnotationElement;
+}(AnnotationElement);
 
-}
+var HighlightAnnotationElement = /*#__PURE__*/function (_AnnotationElement12) {
+  _inherits(HighlightAnnotationElement, _AnnotationElement12);
 
-class SquigglyAnnotationElement extends AnnotationElement {
-  constructor(parameters) {
-    const isRenderable = !!(parameters.data.hasPopup || parameters.data.title || parameters.data.contents);
-    super(parameters, isRenderable, true);
+  var _super18 = _createSuper(HighlightAnnotationElement);
+
+  function HighlightAnnotationElement(parameters) {
+    _classCallCheck(this, HighlightAnnotationElement);
+
+    var isRenderable = !!(parameters.data.hasPopup || parameters.data.title || parameters.data.contents);
+    return _super18.call(this, parameters, isRenderable, true);
   }
 
-  render() {
-    this.container.className = "squigglyAnnotation";
+  _createClass(HighlightAnnotationElement, [{
+    key: "render",
+    value: function render() {
+      this.container.className = "highlightAnnotation";
 
-    if (!this.data.hasPopup) {
-      this._createPopup(this.container, null, this.data);
+      if (!this.data.hasPopup) {
+        this._createPopup(this.container, null, this.data);
+      }
+
+      return this.container;
     }
+  }]);
 
-    return this.container;
-  }
+  return HighlightAnnotationElement;
+}(AnnotationElement);
 
-}
+var UnderlineAnnotationElement = /*#__PURE__*/function (_AnnotationElement13) {
+  _inherits(UnderlineAnnotationElement, _AnnotationElement13);
+
+  var _super19 = _createSuper(UnderlineAnnotationElement);
 
-class StrikeOutAnnotationElement extends AnnotationElement {
-  constructor(parameters) {
-    const isRenderable = !!(parameters.data.hasPopup || parameters.data.title || parameters.data.contents);
-    super(parameters, isRenderable, true);
+  function UnderlineAnnotationElement(parameters) {
+    _classCallCheck(this, UnderlineAnnotationElement);
+
+    var isRenderable = !!(parameters.data.hasPopup || parameters.data.title || parameters.data.contents);
+    return _super19.call(this, parameters, isRenderable, true);
   }
 
-  render() {
-    this.container.className = "strikeoutAnnotation";
+  _createClass(UnderlineAnnotationElement, [{
+    key: "render",
+    value: function render() {
+      this.container.className = "underlineAnnotation";
+
+      if (!this.data.hasPopup) {
+        this._createPopup(this.container, null, this.data);
+      }
 
-    if (!this.data.hasPopup) {
-      this._createPopup(this.container, null, this.data);
+      return this.container;
     }
+  }]);
 
-    return this.container;
-  }
+  return UnderlineAnnotationElement;
+}(AnnotationElement);
 
-}
+var SquigglyAnnotationElement = /*#__PURE__*/function (_AnnotationElement14) {
+  _inherits(SquigglyAnnotationElement, _AnnotationElement14);
+
+  var _super20 = _createSuper(SquigglyAnnotationElement);
+
+  function SquigglyAnnotationElement(parameters) {
+    _classCallCheck(this, SquigglyAnnotationElement);
 
-class StampAnnotationElement extends AnnotationElement {
-  constructor(parameters) {
-    const isRenderable = !!(parameters.data.hasPopup || parameters.data.title || parameters.data.contents);
-    super(parameters, isRenderable, true);
+    var isRenderable = !!(parameters.data.hasPopup || parameters.data.title || parameters.data.contents);
+    return _super20.call(this, parameters, isRenderable, true);
   }
 
-  render() {
-    this.container.className = "stampAnnotation";
+  _createClass(SquigglyAnnotationElement, [{
+    key: "render",
+    value: function render() {
+      this.container.className = "squigglyAnnotation";
+
+      if (!this.data.hasPopup) {
+        this._createPopup(this.container, null, this.data);
+      }
 
-    if (!this.data.hasPopup) {
-      this._createPopup(this.container, null, this.data);
+      return this.container;
     }
+  }]);
+
+  return SquigglyAnnotationElement;
+}(AnnotationElement);
+
+var StrikeOutAnnotationElement = /*#__PURE__*/function (_AnnotationElement15) {
+  _inherits(StrikeOutAnnotationElement, _AnnotationElement15);
 
-    return this.container;
+  var _super21 = _createSuper(StrikeOutAnnotationElement);
+
+  function StrikeOutAnnotationElement(parameters) {
+    _classCallCheck(this, StrikeOutAnnotationElement);
+
+    var isRenderable = !!(parameters.data.hasPopup || parameters.data.title || parameters.data.contents);
+    return _super21.call(this, parameters, isRenderable, true);
   }
 
-}
+  _createClass(StrikeOutAnnotationElement, [{
+    key: "render",
+    value: function render() {
+      this.container.className = "strikeoutAnnotation";
 
-class FileAttachmentAnnotationElement extends AnnotationElement {
-  constructor(parameters) {
-    super(parameters, true);
-    const {
-      filename,
-      content
-    } = this.data.file;
-    this.filename = (0, _display_utils.getFilenameFromUrl)(filename);
-    this.content = content;
-
-    if (this.linkService.eventBus) {
-      this.linkService.eventBus.dispatch("fileattachmentannotation", {
-        source: this,
-        id: (0, _util.stringToPDFString)(filename),
-        filename,
-        content
-      });
+      if (!this.data.hasPopup) {
+        this._createPopup(this.container, null, this.data);
+      }
+
+      return this.container;
     }
+  }]);
+
+  return StrikeOutAnnotationElement;
+}(AnnotationElement);
+
+var StampAnnotationElement = /*#__PURE__*/function (_AnnotationElement16) {
+  _inherits(StampAnnotationElement, _AnnotationElement16);
+
+  var _super22 = _createSuper(StampAnnotationElement);
+
+  function StampAnnotationElement(parameters) {
+    _classCallCheck(this, StampAnnotationElement);
+
+    var isRenderable = !!(parameters.data.hasPopup || parameters.data.title || parameters.data.contents);
+    return _super22.call(this, parameters, isRenderable, true);
   }
 
-  render() {
-    this.container.className = "fileAttachmentAnnotation";
-    const trigger = document.createElement("div");
-    trigger.style.height = this.container.style.height;
-    trigger.style.width = this.container.style.width;
-    trigger.addEventListener("dblclick", this._download.bind(this));
+  _createClass(StampAnnotationElement, [{
+    key: "render",
+    value: function render() {
+      this.container.className = "stampAnnotation";
 
-    if (!this.data.hasPopup && (this.data.title || this.data.contents)) {
-      this._createPopup(this.container, trigger, this.data);
+      if (!this.data.hasPopup) {
+        this._createPopup(this.container, null, this.data);
+      }
+
+      return this.container;
     }
+  }]);
 
-    this.container.appendChild(trigger);
-    return this.container;
-  }
+  return StampAnnotationElement;
+}(AnnotationElement);
 
-  _download() {
-    if (!this.downloadManager) {
-      (0, _util.warn)("Download cannot be started due to unavailable download manager");
-      return;
+var FileAttachmentAnnotationElement = /*#__PURE__*/function (_AnnotationElement17) {
+  _inherits(FileAttachmentAnnotationElement, _AnnotationElement17);
+
+  var _super23 = _createSuper(FileAttachmentAnnotationElement);
+
+  function FileAttachmentAnnotationElement(parameters) {
+    var _this6;
+
+    _classCallCheck(this, FileAttachmentAnnotationElement);
+
+    _this6 = _super23.call(this, parameters, true);
+    var _this6$data$file = _this6.data.file,
+        filename = _this6$data$file.filename,
+        content = _this6$data$file.content;
+    _this6.filename = (0, _display_utils.getFilenameFromUrl)(filename);
+    _this6.content = content;
+
+    if (_this6.linkService.eventBus) {
+      _this6.linkService.eventBus.dispatch("fileattachmentannotation", {
+        source: _assertThisInitialized(_this6),
+        id: (0, _util.stringToPDFString)(filename),
+        filename: filename,
+        content: content
+      });
     }
 
-    this.downloadManager.downloadData(this.content, this.filename, "");
+    return _this6;
   }
 
-}
+  _createClass(FileAttachmentAnnotationElement, [{
+    key: "render",
+    value: function render() {
+      this.container.className = "fileAttachmentAnnotation";
+      var trigger = document.createElement("div");
+      trigger.style.height = this.container.style.height;
+      trigger.style.width = this.container.style.width;
+      trigger.addEventListener("dblclick", this._download.bind(this));
 
-class AnnotationLayer {
-  static render(parameters) {
-    const sortedAnnotations = [],
-          popupAnnotations = [];
-
-    for (const data of parameters.annotations) {
-      if (!data) {
-        continue;
+      if (!this.data.hasPopup && (this.data.title || this.data.contents)) {
+        this._createPopup(this.container, trigger, this.data);
       }
 
-      if (data.annotationType === _util.AnnotationType.POPUP) {
-        popupAnnotations.push(data);
-        continue;
+      this.container.appendChild(trigger);
+      return this.container;
+    }
+  }, {
+    key: "_download",
+    value: function _download() {
+      if (!this.downloadManager) {
+        (0, _util.warn)("Download cannot be started due to unavailable download manager");
+        return;
       }
 
-      sortedAnnotations.push(data);
+      this.downloadManager.downloadData(this.content, this.filename, "");
     }
+  }]);
 
-    if (popupAnnotations.length) {
-      sortedAnnotations.push(...popupAnnotations);
-    }
+  return FileAttachmentAnnotationElement;
+}(AnnotationElement);
 
-    for (const data of sortedAnnotations) {
-      const element = AnnotationElementFactory.create({
-        data,
-        layer: parameters.div,
-        page: parameters.page,
-        viewport: parameters.viewport,
-        linkService: parameters.linkService,
-        downloadManager: parameters.downloadManager,
-        imageResourcesPath: parameters.imageResourcesPath || "",
-        renderInteractiveForms: parameters.renderInteractiveForms || false,
-        svgFactory: new _display_utils.DOMSVGFactory()
-      });
+var AnnotationLayer = /*#__PURE__*/function () {
+  function AnnotationLayer() {
+    _classCallCheck(this, AnnotationLayer);
+  }
+
+  _createClass(AnnotationLayer, null, [{
+    key: "render",
+    value: function render(parameters) {
+      var sortedAnnotations = [],
+          popupAnnotations = [];
+
+      var _iterator5 = _createForOfIteratorHelper(parameters.annotations),
+          _step5;
 
-      if (element.isRenderable) {
-        parameters.div.appendChild(element.render());
+      try {
+        for (_iterator5.s(); !(_step5 = _iterator5.n()).done;) {
+          var _data = _step5.value;
+
+          if (!_data) {
+            continue;
+          }
+
+          if (_data.annotationType === _util.AnnotationType.POPUP) {
+            popupAnnotations.push(_data);
+            continue;
+          }
+
+          sortedAnnotations.push(_data);
+        }
+      } catch (err) {
+        _iterator5.e(err);
+      } finally {
+        _iterator5.f();
+      }
+
+      if (popupAnnotations.length) {
+        sortedAnnotations.push.apply(sortedAnnotations, popupAnnotations);
+      }
+
+      for (var _i = 0, _sortedAnnotations = sortedAnnotations; _i < _sortedAnnotations.length; _i++) {
+        var data = _sortedAnnotations[_i];
+        var element = AnnotationElementFactory.create({
+          data: data,
+          layer: parameters.div,
+          page: parameters.page,
+          viewport: parameters.viewport,
+          linkService: parameters.linkService,
+          downloadManager: parameters.downloadManager,
+          imageResourcesPath: parameters.imageResourcesPath || "",
+          renderInteractiveForms: parameters.renderInteractiveForms || false,
+          svgFactory: new _display_utils.DOMSVGFactory()
+        });
+
+        if (element.isRenderable) {
+          parameters.div.appendChild(element.render());
+        }
       }
     }
-  }
+  }, {
+    key: "update",
+    value: function update(parameters) {
+      var _iterator6 = _createForOfIteratorHelper(parameters.annotations),
+          _step6;
 
-  static update(parameters) {
-    for (const data of parameters.annotations) {
-      const element = parameters.div.querySelector(`[data-annotation-id="${data.id}"]`);
+      try {
+        for (_iterator6.s(); !(_step6 = _iterator6.n()).done;) {
+          var data = _step6.value;
+          var element = parameters.div.querySelector("[data-annotation-id=\"".concat(data.id, "\"]"));
 
-      if (element) {
-        element.style.transform = `matrix(${parameters.viewport.transform.join(",")})`;
+          if (element) {
+            element.style.transform = "matrix(".concat(parameters.viewport.transform.join(","), ")");
+          }
+        }
+      } catch (err) {
+        _iterator6.e(err);
+      } finally {
+        _iterator6.f();
       }
-    }
 
-    parameters.div.removeAttribute("hidden");
-  }
+      parameters.div.removeAttribute("hidden");
+    }
+  }]);
 
-}
+  return AnnotationLayer;
+}();
 
 exports.AnnotationLayer = AnnotationLayer;
 
 /***/ }),
-/* 17 */
+/* 210 */
 /***/ (function(module, exports, __w_pdfjs_require__) {
 
 "use strict";
@@ -9680,7 +21239,7 @@ Object.defineProperty(exports, "__esModule", {
 });
 exports.renderTextLayer = void 0;
 
-var _util = __w_pdfjs_require__(2);
+var _util = __w_pdfjs_require__(5);
 
 var renderTextLayer = function renderTextLayerClosure() {
   var MAX_TEXT_DIVS_TO_RENDER = 100000;
@@ -9732,7 +21291,7 @@ var renderTextLayer = function renderTextLayerClosure() {
       fontAscent = (1 + style.descent) * fontAscent;
     }
 
-    let left, top;
+    var left, top;
 
     if (angle === 0) {
       left = tx[4];
@@ -9742,9 +21301,9 @@ var renderTextLayer = function renderTextLayerClosure() {
       top = tx[5] - fontAscent * Math.cos(angle);
     }
 
-    textDiv.style.left = `${left}px`;
-    textDiv.style.top = `${top}px`;
-    textDiv.style.fontSize = `${fontHeight}px`;
+    textDiv.style.left = "".concat(left, "px");
+    textDiv.style.top = "".concat(top, "px");
+    textDiv.style.fontSize = "".concat(fontHeight, "px");
     textDiv.style.fontFamily = style.fontFamily;
     textDiv.textContent = geom.str;
 
@@ -9756,13 +21315,13 @@ var renderTextLayer = function renderTextLayerClosure() {
       textDivProperties.angle = angle * (180 / Math.PI);
     }
 
-    let shouldScaleText = false;
+    var shouldScaleText = false;
 
     if (geom.str.length > 1) {
       shouldScaleText = true;
     } else if (geom.transform[0] !== geom.transform[3]) {
-      const absScaleX = Math.abs(geom.transform[0]),
-            absScaleY = Math.abs(geom.transform[3]);
+      var absScaleX = Math.abs(geom.transform[0]),
+          absScaleY = Math.abs(geom.transform[3]);
 
       if (absScaleX !== absScaleY && Math.max(absScaleX, absScaleY) / Math.min(absScaleX, absScaleY) > 1.5) {
         shouldScaleText = true;
@@ -9810,7 +21369,7 @@ var renderTextLayer = function renderTextLayerClosure() {
         bottom: b[3],
         div: textDiv,
         size: [divWidth, divHeight],
-        m
+        m: m
       });
     }
   }
@@ -9841,10 +21400,10 @@ var renderTextLayer = function renderTextLayerClosure() {
   }
 
   function findPositiveMin(ts, offset, count) {
-    let result = 0;
+    var result = 0;
 
-    for (let i = 0; i < count; i++) {
-      const t = ts[offset++];
+    for (var i = 0; i < count; i++) {
+      var t = ts[offset++];
 
       if (t > 0) {
         result = result ? Math.min(t, result) : t;
@@ -10104,15 +21663,16 @@ var renderTextLayer = function renderTextLayerClosure() {
     });
   }
 
-  function TextLayerRenderTask({
-    textContent,
-    textContentStream,
-    container,
-    viewport,
-    textDivs,
-    textContentItemsStr,
-    enhanceTextSelection
-  }) {
+  function TextLayerRenderTask(_ref) {
+    var _this = this;
+
+    var textContent = _ref.textContent,
+        textContentStream = _ref.textContentStream,
+        container = _ref.container,
+        viewport = _ref.viewport,
+        textDivs = _ref.textDivs,
+        textContentItemsStr = _ref.textContentItemsStr,
+        enhanceTextSelection = _ref.enhanceTextSelection;
     this._textContent = textContent;
     this._textContentStream = textContentStream;
     this._container = container;
@@ -10132,13 +21692,13 @@ var renderTextLayer = function renderTextLayerClosure() {
     this._renderTimer = null;
     this._bounds = [];
 
-    this._capability.promise.finally(() => {
-      if (this._layoutTextCtx) {
-        this._layoutTextCtx.canvas.width = 0;
-        this._layoutTextCtx.canvas.height = 0;
-        this._layoutTextCtx = null;
+    this._capability.promise["finally"](function () {
+      if (_this._layoutTextCtx) {
+        _this._layoutTextCtx.canvas.width = 0;
+        _this._layoutTextCtx.canvas.height = 0;
+        _this._layoutTextCtx = null;
       }
-    }).catch(() => {});
+    })["catch"](function () {});
   }
 
   TextLayerRenderTask.prototype = {
@@ -10162,48 +21722,44 @@ var renderTextLayer = function renderTextLayerClosure() {
 
       this._capability.reject(new Error("TextLayer task cancelled."));
     },
-
-    _processItems(items, styleCache) {
-      for (let i = 0, len = items.length; i < len; i++) {
+    _processItems: function _processItems(items, styleCache) {
+      for (var i = 0, len = items.length; i < len; i++) {
         this._textContentItemsStr.push(items[i].str);
 
         appendText(this, items[i], styleCache);
       }
     },
-
-    _layoutText(textDiv) {
-      const textDivProperties = this._textDivProperties.get(textDiv);
+    _layoutText: function _layoutText(textDiv) {
+      var textDivProperties = this._textDivProperties.get(textDiv);
 
       if (textDivProperties.isWhitespace) {
         return;
       }
 
-      let transform = "";
+      var transform = "";
 
       if (textDivProperties.canvasWidth !== 0) {
-        const {
-          fontSize,
-          fontFamily
-        } = textDiv.style;
+        var _textDiv$style = textDiv.style,
+            fontSize = _textDiv$style.fontSize,
+            fontFamily = _textDiv$style.fontFamily;
 
         if (fontSize !== this._layoutTextLastFontSize || fontFamily !== this._layoutTextLastFontFamily) {
-          this._layoutTextCtx.font = `${fontSize} ${fontFamily}`;
+          this._layoutTextCtx.font = "".concat(fontSize, " ").concat(fontFamily);
           this._layoutTextLastFontSize = fontSize;
           this._layoutTextLastFontFamily = fontFamily;
         }
 
-        const {
-          width
-        } = this._layoutTextCtx.measureText(textDiv.textContent);
+        var _this$_layoutTextCtx$ = this._layoutTextCtx.measureText(textDiv.textContent),
+            width = _this$_layoutTextCtx$.width;
 
         if (width > 0) {
           textDivProperties.scale = textDivProperties.canvasWidth / width;
-          transform = `scaleX(${textDivProperties.scale})`;
+          transform = "scaleX(".concat(textDivProperties.scale, ")");
         }
       }
 
       if (textDivProperties.angle !== 0) {
-        transform = `rotate(${textDivProperties.angle}deg) ${transform}`;
+        transform = "rotate(".concat(textDivProperties.angle, "deg) ").concat(transform);
       }
 
       if (transform.length > 0) {
@@ -10218,29 +21774,30 @@ var renderTextLayer = function renderTextLayerClosure() {
 
       this._container.appendChild(textDiv);
     },
-
     _render: function TextLayer_render(timeout) {
-      const capability = (0, _util.createPromiseCapability)();
-      let styleCache = Object.create(null);
-      const canvas = document.createElement("canvas");
+      var _this2 = this;
+
+      var capability = (0, _util.createPromiseCapability)();
+      var styleCache = Object.create(null);
+      var canvas = document.createElement("canvas");
       canvas.mozOpaque = true;
       this._layoutTextCtx = canvas.getContext("2d", {
         alpha: false
       });
 
       if (this._textContent) {
-        const textItems = this._textContent.items;
-        const textStyles = this._textContent.styles;
+        var textItems = this._textContent.items;
+        var textStyles = this._textContent.styles;
 
         this._processItems(textItems, textStyles);
 
         capability.resolve();
       } else if (this._textContentStream) {
-        const pump = () => {
-          this._reader.read().then(({
-            value,
-            done
-          }) => {
+        var pump = function pump() {
+          _this2._reader.read().then(function (_ref2) {
+            var value = _ref2.value,
+                done = _ref2.done;
+
             if (done) {
               capability.resolve();
               return;
@@ -10248,7 +21805,7 @@ var renderTextLayer = function renderTextLayerClosure() {
 
             Object.assign(styleCache, value.styles);
 
-            this._processItems(value.items, styleCache);
+            _this2._processItems(value.items, styleCache);
 
             pump();
           }, capability.reject);
@@ -10260,15 +21817,15 @@ var renderTextLayer = function renderTextLayerClosure() {
         throw new Error('Neither "textContent" nor "textContentStream"' + " parameters specified.");
       }
 
-      capability.promise.then(() => {
+      capability.promise.then(function () {
         styleCache = null;
 
         if (!timeout) {
-          render(this);
+          render(_this2);
         } else {
-          this._renderTimer = setTimeout(() => {
-            render(this);
-            this._renderTimer = null;
+          _this2._renderTimer = setTimeout(function () {
+            render(_this2);
+            _this2._renderTimer = null;
           }, timeout);
         }
       }, this._capability.reject);
@@ -10283,13 +21840,13 @@ var renderTextLayer = function renderTextLayerClosure() {
         this._bounds = null;
       }
 
-      const transformBuf = [],
-            paddingBuf = [];
+      var transformBuf = [],
+          paddingBuf = [];
 
       for (var i = 0, ii = this._textDivs.length; i < ii; i++) {
-        const div = this._textDivs[i];
+        var div = this._textDivs[i];
 
-        const divProps = this._textDivProperties.get(div);
+        var divProps = this._textDivProperties.get(div);
 
         if (divProps.isWhitespace) {
           continue;
@@ -10304,27 +21861,27 @@ var renderTextLayer = function renderTextLayerClosure() {
           }
 
           if (divProps.paddingTop > 0) {
-            paddingBuf.push(`${divProps.paddingTop}px`);
-            transformBuf.push(`translateY(${-divProps.paddingTop}px)`);
+            paddingBuf.push("".concat(divProps.paddingTop, "px"));
+            transformBuf.push("translateY(".concat(-divProps.paddingTop, "px)"));
           } else {
             paddingBuf.push(0);
           }
 
           if (divProps.paddingRight > 0) {
-            paddingBuf.push(`${divProps.paddingRight / divProps.scale}px`);
+            paddingBuf.push("".concat(divProps.paddingRight / divProps.scale, "px"));
           } else {
             paddingBuf.push(0);
           }
 
           if (divProps.paddingBottom > 0) {
-            paddingBuf.push(`${divProps.paddingBottom}px`);
+            paddingBuf.push("".concat(divProps.paddingBottom, "px"));
           } else {
             paddingBuf.push(0);
           }
 
           if (divProps.paddingLeft > 0) {
-            paddingBuf.push(`${divProps.paddingLeft / divProps.scale}px`);
-            transformBuf.push(`translateX(${-divProps.paddingLeft / divProps.scale}px)`);
+            paddingBuf.push("".concat(divProps.paddingLeft / divProps.scale, "px"));
+            transformBuf.push("translateX(".concat(-divProps.paddingLeft / divProps.scale, "px)"));
           } else {
             paddingBuf.push(0);
           }
@@ -10364,7 +21921,7 @@ var renderTextLayer = function renderTextLayerClosure() {
 exports.renderTextLayer = renderTextLayer;
 
 /***/ }),
-/* 18 */
+/* 211 */
 /***/ (function(module, exports, __w_pdfjs_require__) {
 
 "use strict";
@@ -10375,37 +21932,144 @@ Object.defineProperty(exports, "__esModule", {
 });
 exports.SVGGraphics = void 0;
 
-var _util = __w_pdfjs_require__(2);
+var _util = __w_pdfjs_require__(5);
 
 var _display_utils = __w_pdfjs_require__(1);
 
-var _is_node = __w_pdfjs_require__(4);
+var _is_node = __w_pdfjs_require__(7);
+
+function _toConsumableArray(arr) { return _arrayWithoutHoles(arr) || _iterableToArray(arr) || _unsupportedIterableToArray(arr) || _nonIterableSpread(); }
+
+function _nonIterableSpread() { throw new TypeError("Invalid attempt to spread non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method."); }
+
+function _iterableToArray(iter) { if (typeof Symbol !== "undefined" && Symbol.iterator in Object(iter)) return Array.from(iter); }
+
+function _arrayWithoutHoles(arr) { if (Array.isArray(arr)) return _arrayLikeToArray(arr); }
+
+function _slicedToArray(arr, i) { return _arrayWithHoles(arr) || _iterableToArrayLimit(arr, i) || _unsupportedIterableToArray(arr, i) || _nonIterableRest(); }
 
-let SVGGraphics = function () {
+function _nonIterableRest() { throw new TypeError("Invalid attempt to destructure non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method."); }
+
+function _iterableToArrayLimit(arr, i) { if (typeof Symbol === "undefined" || !(Symbol.iterator in Object(arr))) return; var _arr = []; var _n = true; var _d = false; var _e = undefined; try { for (var _i = arr[Symbol.iterator](), _s; !(_n = (_s = _i.next()).done); _n = true) { _arr.push(_s.value); if (i && _arr.length === i) break; } } catch (err) { _d = true; _e = err; } finally { try { if (!_n && _i["return"] != null) _i["return"](); } finally { if (_d) throw _e; } } return _arr; }
+
+function _arrayWithHoles(arr) { if (Array.isArray(arr)) return arr; }
+
+function _createForOfIteratorHelper(o, allowArrayLike) { var it; if (typeof Symbol === "undefined" || o[Symbol.iterator] == null) { if (Array.isArray(o) || (it = _unsupportedIterableToArray(o)) || allowArrayLike && o && typeof o.length === "number") { if (it) o = it; var i = 0; var F = function F() {}; return { s: F, n: function n() { if (i >= o.length) return { done: true }; return { done: false, value: o[i++] }; }, e: function e(_e2) { throw _e2; }, f: F }; } throw new TypeError("Invalid attempt to iterate non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method."); } var normalCompletion = true, didErr = false, err; return { s: function s() { it = o[Symbol.iterator](); }, n: function n() { var step = it.next(); normalCompletion = step.done; return step; }, e: function e(_e3) { didErr = true; err = _e3; }, f: function f() { try { if (!normalCompletion && it["return"] != null) it["return"](); } finally { if (didErr) throw err; } } }; }
+
+function _unsupportedIterableToArray(o, minLen) { if (!o) return; if (typeof o === "string") return _arrayLikeToArray(o, minLen); var n = Object.prototype.toString.call(o).slice(8, -1); if (n === "Object" && o.constructor) n = o.constructor.name; if (n === "Map" || n === "Set") return Array.from(o); if (n === "Arguments" || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(n)) return _arrayLikeToArray(o, minLen); }
+
+function _arrayLikeToArray(arr, len) { if (len == null || len > arr.length) len = arr.length; for (var i = 0, arr2 = new Array(len); i < len; i++) { arr2[i] = arr[i]; } return arr2; }
+
+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 SVGGraphics = function SVGGraphics() {
   throw new Error("Not implemented: SVGGraphics");
 };
 
 exports.SVGGraphics = SVGGraphics;
 {
-  const SVG_DEFAULTS = {
+  var opListToTree = function opListToTree(opList) {
+    var opTree = [];
+    var tmp = [];
+
+    var _iterator = _createForOfIteratorHelper(opList),
+        _step;
+
+    try {
+      for (_iterator.s(); !(_step = _iterator.n()).done;) {
+        var opListElement = _step.value;
+
+        if (opListElement.fn === "save") {
+          opTree.push({
+            fnId: 92,
+            fn: "group",
+            items: []
+          });
+          tmp.push(opTree);
+          opTree = opTree[opTree.length - 1].items;
+          continue;
+        }
+
+        if (opListElement.fn === "restore") {
+          opTree = tmp.pop();
+        } else {
+          opTree.push(opListElement);
+        }
+      }
+    } catch (err) {
+      _iterator.e(err);
+    } finally {
+      _iterator.f();
+    }
+
+    return opTree;
+  };
+
+  var pf = function pf(value) {
+    if (Number.isInteger(value)) {
+      return value.toString();
+    }
+
+    var s = value.toFixed(10);
+    var i = s.length - 1;
+
+    if (s[i] !== "0") {
+      return s;
+    }
+
+    do {
+      i--;
+    } while (s[i] === "0");
+
+    return s.substring(0, s[i] === "." ? i : i + 1);
+  };
+
+  var pm = function pm(m) {
+    if (m[4] === 0 && m[5] === 0) {
+      if (m[1] === 0 && m[2] === 0) {
+        if (m[0] === 1 && m[3] === 1) {
+          return "";
+        }
+
+        return "scale(".concat(pf(m[0]), " ").concat(pf(m[3]), ")");
+      }
+
+      if (m[0] === m[3] && m[1] === -m[2]) {
+        var a = Math.acos(m[0]) * 180 / Math.PI;
+        return "rotate(".concat(pf(a), ")");
+      }
+    } else {
+      if (m[0] === 1 && m[1] === 0 && m[2] === 0 && m[3] === 1) {
+        return "translate(".concat(pf(m[4]), " ").concat(pf(m[5]), ")");
+      }
+    }
+
+    return "matrix(".concat(pf(m[0]), " ").concat(pf(m[1]), " ").concat(pf(m[2]), " ").concat(pf(m[3]), " ").concat(pf(m[4]), " ") + "".concat(pf(m[5]), ")");
+  };
+
+  var SVG_DEFAULTS = {
     fontStyle: "normal",
     fontWeight: "normal",
     fillColor: "#000000"
   };
-  const XML_NS = "http://www.w3.org/XML/1998/namespace";
-  const XLINK_NS = "http://www.w3.org/1999/xlink";
-  const LINE_CAP_STYLES = ["butt", "round", "square"];
-  const LINE_JOIN_STYLES = ["miter", "round", "bevel"];
+  var XML_NS = "http://www.w3.org/XML/1998/namespace";
+  var XLINK_NS = "http://www.w3.org/1999/xlink";
+  var LINE_CAP_STYLES = ["butt", "round", "square"];
+  var LINE_JOIN_STYLES = ["miter", "round", "bevel"];
 
-  const convertImgDataToPng = function () {
-    const PNG_HEADER = new Uint8Array([0x89, 0x50, 0x4e, 0x47, 0x0d, 0x0a, 0x1a, 0x0a]);
-    const CHUNK_WRAPPER_SIZE = 12;
-    const crcTable = new Int32Array(256);
+  var convertImgDataToPng = function () {
+    var PNG_HEADER = new Uint8Array([0x89, 0x50, 0x4e, 0x47, 0x0d, 0x0a, 0x1a, 0x0a]);
+    var CHUNK_WRAPPER_SIZE = 12;
+    var crcTable = new Int32Array(256);
 
-    for (let i = 0; i < 256; i++) {
-      let c = i;
+    for (var i = 0; i < 256; i++) {
+      var c = i;
 
-      for (let h = 0; h < 8; h++) {
+      for (var h = 0; h < 8; h++) {
         if (c & 1) {
           c = 0xedb88320 ^ c >> 1 & 0x7fffffff;
         } else {
@@ -10417,11 +22081,11 @@ exports.SVGGraphics = SVGGraphics;
     }
 
     function crc32(data, start, end) {
-      let crc = -1;
+      var crc = -1;
 
-      for (let i = start; i < end; i++) {
-        const a = (crc ^ data[i]) & 0xff;
-        const b = crcTable[a];
+      for (var _i = start; _i < end; _i++) {
+        var a = (crc ^ data[_i]) & 0xff;
+        var b = crcTable[a];
         crc = crc >>> 8 ^ b;
       }
 
@@ -10429,8 +22093,8 @@ exports.SVGGraphics = SVGGraphics;
     }
 
     function writePngChunk(type, body, data, offset) {
-      let p = offset;
-      const len = body.length;
+      var p = offset;
+      var len = body.length;
       data[p] = len >> 24 & 0xff;
       data[p + 1] = len >> 16 & 0xff;
       data[p + 2] = len >> 8 & 0xff;
@@ -10443,7 +22107,7 @@ exports.SVGGraphics = SVGGraphics;
       p += 4;
       data.set(body, p);
       p += body.length;
-      const crc = crc32(data, offset + 4, p);
+      var crc = crc32(data, offset + 4, p);
       data[p] = crc >> 24 & 0xff;
       data[p + 1] = crc >> 16 & 0xff;
       data[p + 2] = crc >> 8 & 0xff;
@@ -10451,11 +22115,11 @@ exports.SVGGraphics = SVGGraphics;
     }
 
     function adler32(data, start, end) {
-      let a = 1;
-      let b = 0;
+      var a = 1;
+      var b = 0;
 
-      for (let i = start; i < end; ++i) {
-        a = (a + (data[i] & 0xff)) % 65521;
+      for (var _i2 = start; _i2 < end; ++_i2) {
+        a = (a + (data[_i2] & 0xff)) % 65521;
         b = (b + a) % 65521;
       }
 
@@ -10468,7 +22132,7 @@ exports.SVGGraphics = SVGGraphics;
       }
 
       try {
-        let input;
+        var input;
 
         if (parseInt(process.versions.node) >= 8) {
           input = literals;
@@ -10476,7 +22140,7 @@ exports.SVGGraphics = SVGGraphics;
           input = Buffer.from(literals);
         }
 
-        const output = require("zlib").deflateSync(input, {
+        var output = require("zlib").deflateSync(input, {
           level: 9
         });
 
@@ -10489,14 +22153,14 @@ exports.SVGGraphics = SVGGraphics;
     }
 
     function deflateSyncUncompressed(literals) {
-      let len = literals.length;
-      const maxBlockLength = 0xffff;
-      const deflateBlocks = Math.ceil(len / maxBlockLength);
-      const idat = new Uint8Array(2 + len + deflateBlocks * 5 + 4);
-      let pi = 0;
+      var len = literals.length;
+      var maxBlockLength = 0xffff;
+      var deflateBlocks = Math.ceil(len / maxBlockLength);
+      var idat = new Uint8Array(2 + len + deflateBlocks * 5 + 4);
+      var pi = 0;
       idat[pi++] = 0x78;
       idat[pi++] = 0x9c;
-      let pos = 0;
+      var pos = 0;
 
       while (len > maxBlockLength) {
         idat[pi++] = 0x00;
@@ -10517,7 +22181,7 @@ exports.SVGGraphics = SVGGraphics;
       idat[pi++] = (~len & 0xffff) >> 8 & 0xff;
       idat.set(literals.subarray(pos), pi);
       pi += literals.length - pos;
-      const adler = adler32(literals, 0, literals.length);
+      var adler = adler32(literals, 0, literals.length);
       idat[pi++] = adler >> 24 & 0xff;
       idat[pi++] = adler >> 16 & 0xff;
       idat[pi++] = adler >> 8 & 0xff;
@@ -10526,10 +22190,10 @@ exports.SVGGraphics = SVGGraphics;
     }
 
     function encode(imgData, kind, forceDataSchema, isMask) {
-      const width = imgData.width;
-      const height = imgData.height;
-      let bitDepth, colorType, lineSize;
-      const bytes = imgData.data;
+      var width = imgData.width;
+      var height = imgData.height;
+      var bitDepth, colorType, lineSize;
+      var bytes = imgData.data;
 
       switch (kind) {
         case _util.ImageKind.GRAYSCALE_1BPP:
@@ -10554,11 +22218,11 @@ exports.SVGGraphics = SVGGraphics;
           throw new Error("invalid format");
       }
 
-      const literals = new Uint8Array((1 + lineSize) * height);
-      let offsetLiterals = 0,
+      var literals = new Uint8Array((1 + lineSize) * height);
+      var offsetLiterals = 0,
           offsetBytes = 0;
 
-      for (let y = 0; y < height; ++y) {
+      for (var y = 0; y < height; ++y) {
         literals[offsetLiterals++] = 0;
         literals.set(bytes.subarray(offsetBytes, offsetBytes + lineSize), offsetLiterals);
         offsetBytes += lineSize;
@@ -10568,20 +22232,20 @@ exports.SVGGraphics = SVGGraphics;
       if (kind === _util.ImageKind.GRAYSCALE_1BPP && isMask) {
         offsetLiterals = 0;
 
-        for (let y = 0; y < height; y++) {
+        for (var _y = 0; _y < height; _y++) {
           offsetLiterals++;
 
-          for (let i = 0; i < lineSize; i++) {
+          for (var _i3 = 0; _i3 < lineSize; _i3++) {
             literals[offsetLiterals++] ^= 0xff;
           }
         }
       }
 
-      const ihdr = new Uint8Array([width >> 24 & 0xff, width >> 16 & 0xff, width >> 8 & 0xff, width & 0xff, height >> 24 & 0xff, height >> 16 & 0xff, height >> 8 & 0xff, height & 0xff, bitDepth, colorType, 0x00, 0x00, 0x00]);
-      const idat = deflateSync(literals);
-      const pngLength = PNG_HEADER.length + CHUNK_WRAPPER_SIZE * 3 + ihdr.length + idat.length;
-      const data = new Uint8Array(pngLength);
-      let offset = 0;
+      var ihdr = new Uint8Array([width >> 24 & 0xff, width >> 16 & 0xff, width >> 8 & 0xff, width & 0xff, height >> 24 & 0xff, height >> 16 & 0xff, height >> 8 & 0xff, height & 0xff, bitDepth, colorType, 0x00, 0x00, 0x00]);
+      var idat = deflateSync(literals);
+      var pngLength = PNG_HEADER.length + CHUNK_WRAPPER_SIZE * 3 + ihdr.length + idat.length;
+      var data = new Uint8Array(pngLength);
+      var offset = 0;
       data.set(PNG_HEADER, offset);
       offset += PNG_HEADER.length;
       writePngChunk("IHDR", ihdr, data, offset);
@@ -10593,13 +22257,15 @@ exports.SVGGraphics = SVGGraphics;
     }
 
     return function convertImgDataToPng(imgData, forceDataSchema, isMask) {
-      const kind = imgData.kind === undefined ? _util.ImageKind.GRAYSCALE_1BPP : imgData.kind;
+      var kind = imgData.kind === undefined ? _util.ImageKind.GRAYSCALE_1BPP : imgData.kind;
       return encode(imgData, kind, forceDataSchema, isMask);
     };
   }();
 
-  class SVGExtraState {
-    constructor() {
+  var SVGExtraState = /*#__PURE__*/function () {
+    function SVGExtraState() {
+      _classCallCheck(this, SVGExtraState);
+
       this.fontSizeScale = 1;
       this.fontWeight = SVG_DEFAULTS.fontWeight;
       this.fontSize = 0;
@@ -10632,90 +22298,32 @@ exports.SVGGraphics = SVGGraphics;
       this.maskId = "";
     }
 
-    clone() {
-      return Object.create(this);
-    }
-
-    setCurrentPoint(x, y) {
-      this.x = x;
-      this.y = y;
-    }
-
-  }
-
-  function opListToTree(opList) {
-    let opTree = [];
-    const tmp = [];
-
-    for (const opListElement of opList) {
-      if (opListElement.fn === "save") {
-        opTree.push({
-          fnId: 92,
-          fn: "group",
-          items: []
-        });
-        tmp.push(opTree);
-        opTree = opTree[opTree.length - 1].items;
-        continue;
+    _createClass(SVGExtraState, [{
+      key: "clone",
+      value: function clone() {
+        return Object.create(this);
       }
-
-      if (opListElement.fn === "restore") {
-        opTree = tmp.pop();
-      } else {
-        opTree.push(opListElement);
+    }, {
+      key: "setCurrentPoint",
+      value: function setCurrentPoint(x, y) {
+        this.x = x;
+        this.y = y;
       }
-    }
-
-    return opTree;
-  }
-
-  function pf(value) {
-    if (Number.isInteger(value)) {
-      return value.toString();
-    }
-
-    const s = value.toFixed(10);
-    let i = s.length - 1;
-
-    if (s[i] !== "0") {
-      return s;
-    }
-
-    do {
-      i--;
-    } while (s[i] === "0");
+    }]);
 
-    return s.substring(0, s[i] === "." ? i : i + 1);
-  }
+    return SVGExtraState;
+  }();
 
-  function pm(m) {
-    if (m[4] === 0 && m[5] === 0) {
-      if (m[1] === 0 && m[2] === 0) {
-        if (m[0] === 1 && m[3] === 1) {
-          return "";
-        }
+  var clipCount = 0;
+  var maskCount = 0;
+  var shadingCount = 0;
 
-        return `scale(${pf(m[0])} ${pf(m[3])})`;
-      }
+  exports.SVGGraphics = SVGGraphics = /*#__PURE__*/function () {
+    function SVGGraphics(commonObjs, objs) {
+      var forceDataSchema = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : false;
 
-      if (m[0] === m[3] && m[1] === -m[2]) {
-        const a = Math.acos(m[0]) * 180 / Math.PI;
-        return `rotate(${pf(a)})`;
-      }
-    } else {
-      if (m[0] === 1 && m[1] === 0 && m[2] === 0 && m[3] === 1) {
-        return `translate(${pf(m[4])} ${pf(m[5])})`;
-      }
-    }
+      _classCallCheck(this, SVGGraphics);
 
-    return `matrix(${pf(m[0])} ${pf(m[1])} ${pf(m[2])} ${pf(m[3])} ${pf(m[4])} ` + `${pf(m[5])})`;
-  }
-
-  let clipCount = 0;
-  let maskCount = 0;
-  let shadingCount = 0;
-  exports.SVGGraphics = SVGGraphics = class SVGGraphics {
-    constructor(commonObjs, objs, forceDataSchema = false) {
       this.svgFactory = new _display_utils.DOMSVGFactory();
       this.current = new SVGExtraState();
       this.transformMatrix = _util.IDENTITY_MATRIX;
@@ -10731,1166 +22339,1325 @@ exports.SVGGraphics = SVGGraphics;
       this.forceDataSchema = !!forceDataSchema;
       this._operatorIdMapping = [];
 
-      for (const op in _util.OPS) {
+      for (var op in _util.OPS) {
         this._operatorIdMapping[_util.OPS[op]] = op;
       }
     }
 
-    save() {
-      this.transformStack.push(this.transformMatrix);
-      const old = this.current;
-      this.extraStack.push(old);
-      this.current = old.clone();
-    }
+    _createClass(SVGGraphics, [{
+      key: "save",
+      value: function save() {
+        this.transformStack.push(this.transformMatrix);
+        var old = this.current;
+        this.extraStack.push(old);
+        this.current = old.clone();
+      }
+    }, {
+      key: "restore",
+      value: function restore() {
+        this.transformMatrix = this.transformStack.pop();
+        this.current = this.extraStack.pop();
+        this.pendingClip = null;
+        this.tgrp = null;
+      }
+    }, {
+      key: "group",
+      value: function group(items) {
+        this.save();
+        this.executeOpTree(items);
+        this.restore();
+      }
+    }, {
+      key: "loadDependencies",
+      value: function loadDependencies(operatorList) {
+        var _this = this;
 
-    restore() {
-      this.transformMatrix = this.transformStack.pop();
-      this.current = this.extraStack.pop();
-      this.pendingClip = null;
-      this.tgrp = null;
-    }
+        var fnArray = operatorList.fnArray;
+        var argsArray = operatorList.argsArray;
 
-    group(items) {
-      this.save();
-      this.executeOpTree(items);
-      this.restore();
-    }
+        for (var i = 0, ii = fnArray.length; i < ii; i++) {
+          if (fnArray[i] !== _util.OPS.dependency) {
+            continue;
+          }
 
-    loadDependencies(operatorList) {
-      const fnArray = operatorList.fnArray;
-      const argsArray = operatorList.argsArray;
+          var _iterator2 = _createForOfIteratorHelper(argsArray[i]),
+              _step2;
 
-      for (let i = 0, ii = fnArray.length; i < ii; i++) {
-        if (fnArray[i] !== _util.OPS.dependency) {
-          continue;
-        }
+          try {
+            var _loop = function _loop() {
+              var obj = _step2.value;
+              var objsPool = obj.startsWith("g_") ? _this.commonObjs : _this.objs;
+              var promise = new Promise(function (resolve) {
+                objsPool.get(obj, resolve);
+              });
 
-        for (const obj of argsArray[i]) {
-          const objsPool = obj.startsWith("g_") ? this.commonObjs : this.objs;
-          const promise = new Promise(resolve => {
-            objsPool.get(obj, resolve);
-          });
-          this.current.dependencies.push(promise);
-        }
-      }
+              _this.current.dependencies.push(promise);
+            };
 
-      return Promise.all(this.current.dependencies);
-    }
+            for (_iterator2.s(); !(_step2 = _iterator2.n()).done;) {
+              _loop();
+            }
+          } catch (err) {
+            _iterator2.e(err);
+          } finally {
+            _iterator2.f();
+          }
+        }
 
-    transform(a, b, c, d, e, f) {
-      const transformMatrix = [a, b, c, d, e, f];
-      this.transformMatrix = _util.Util.transform(this.transformMatrix, transformMatrix);
-      this.tgrp = null;
-    }
+        return Promise.all(this.current.dependencies);
+      }
+    }, {
+      key: "transform",
+      value: function transform(a, b, c, d, e, f) {
+        var transformMatrix = [a, b, c, d, e, f];
+        this.transformMatrix = _util.Util.transform(this.transformMatrix, transformMatrix);
+        this.tgrp = null;
+      }
+    }, {
+      key: "getSVG",
+      value: function getSVG(operatorList, viewport) {
+        var _this2 = this;
 
-    getSVG(operatorList, viewport) {
-      this.viewport = viewport;
+        this.viewport = viewport;
 
-      const svgElement = this._initialize(viewport);
+        var svgElement = this._initialize(viewport);
 
-      return this.loadDependencies(operatorList).then(() => {
-        this.transformMatrix = _util.IDENTITY_MATRIX;
-        this.executeOpTree(this.convertOpList(operatorList));
-        return svgElement;
-      });
-    }
+        return this.loadDependencies(operatorList).then(function () {
+          _this2.transformMatrix = _util.IDENTITY_MATRIX;
 
-    convertOpList(operatorList) {
-      const operatorIdMapping = this._operatorIdMapping;
-      const argsArray = operatorList.argsArray;
-      const fnArray = operatorList.fnArray;
-      const opList = [];
+          _this2.executeOpTree(_this2.convertOpList(operatorList));
 
-      for (let i = 0, ii = fnArray.length; i < ii; i++) {
-        const fnId = fnArray[i];
-        opList.push({
-          fnId,
-          fn: operatorIdMapping[fnId],
-          args: argsArray[i]
+          return svgElement;
         });
       }
+    }, {
+      key: "convertOpList",
+      value: function convertOpList(operatorList) {
+        var operatorIdMapping = this._operatorIdMapping;
+        var argsArray = operatorList.argsArray;
+        var fnArray = operatorList.fnArray;
+        var opList = [];
+
+        for (var i = 0, ii = fnArray.length; i < ii; i++) {
+          var fnId = fnArray[i];
+          opList.push({
+            fnId: fnId,
+            fn: operatorIdMapping[fnId],
+            args: argsArray[i]
+          });
+        }
 
-      return opListToTree(opList);
-    }
+        return opListToTree(opList);
+      }
+    }, {
+      key: "executeOpTree",
+      value: function executeOpTree(opTree) {
+        var _iterator3 = _createForOfIteratorHelper(opTree),
+            _step3;
 
-    executeOpTree(opTree) {
-      for (const opTreeElement of opTree) {
-        const fn = opTreeElement.fn;
-        const fnId = opTreeElement.fnId;
-        const args = opTreeElement.args;
+        try {
+          for (_iterator3.s(); !(_step3 = _iterator3.n()).done;) {
+            var opTreeElement = _step3.value;
+            var fn = opTreeElement.fn;
+            var fnId = opTreeElement.fnId;
+            var args = opTreeElement.args;
 
-        switch (fnId | 0) {
-          case _util.OPS.beginText:
-            this.beginText();
-            break;
+            switch (fnId | 0) {
+              case _util.OPS.beginText:
+                this.beginText();
+                break;
 
-          case _util.OPS.dependency:
-            break;
+              case _util.OPS.dependency:
+                break;
 
-          case _util.OPS.setLeading:
-            this.setLeading(args);
-            break;
+              case _util.OPS.setLeading:
+                this.setLeading(args);
+                break;
 
-          case _util.OPS.setLeadingMoveText:
-            this.setLeadingMoveText(args[0], args[1]);
-            break;
+              case _util.OPS.setLeadingMoveText:
+                this.setLeadingMoveText(args[0], args[1]);
+                break;
 
-          case _util.OPS.setFont:
-            this.setFont(args);
-            break;
+              case _util.OPS.setFont:
+                this.setFont(args);
+                break;
 
-          case _util.OPS.showText:
-            this.showText(args[0]);
-            break;
+              case _util.OPS.showText:
+                this.showText(args[0]);
+                break;
 
-          case _util.OPS.showSpacedText:
-            this.showText(args[0]);
-            break;
+              case _util.OPS.showSpacedText:
+                this.showText(args[0]);
+                break;
 
-          case _util.OPS.endText:
-            this.endText();
-            break;
+              case _util.OPS.endText:
+                this.endText();
+                break;
 
-          case _util.OPS.moveText:
-            this.moveText(args[0], args[1]);
-            break;
+              case _util.OPS.moveText:
+                this.moveText(args[0], args[1]);
+                break;
 
-          case _util.OPS.setCharSpacing:
-            this.setCharSpacing(args[0]);
-            break;
+              case _util.OPS.setCharSpacing:
+                this.setCharSpacing(args[0]);
+                break;
 
-          case _util.OPS.setWordSpacing:
-            this.setWordSpacing(args[0]);
-            break;
+              case _util.OPS.setWordSpacing:
+                this.setWordSpacing(args[0]);
+                break;
 
-          case _util.OPS.setHScale:
-            this.setHScale(args[0]);
-            break;
+              case _util.OPS.setHScale:
+                this.setHScale(args[0]);
+                break;
 
-          case _util.OPS.setTextMatrix:
-            this.setTextMatrix(args[0], args[1], args[2], args[3], args[4], args[5]);
-            break;
+              case _util.OPS.setTextMatrix:
+                this.setTextMatrix(args[0], args[1], args[2], args[3], args[4], args[5]);
+                break;
 
-          case _util.OPS.setTextRise:
-            this.setTextRise(args[0]);
-            break;
+              case _util.OPS.setTextRise:
+                this.setTextRise(args[0]);
+                break;
 
-          case _util.OPS.setTextRenderingMode:
-            this.setTextRenderingMode(args[0]);
-            break;
+              case _util.OPS.setTextRenderingMode:
+                this.setTextRenderingMode(args[0]);
+                break;
 
-          case _util.OPS.setLineWidth:
-            this.setLineWidth(args[0]);
-            break;
+              case _util.OPS.setLineWidth:
+                this.setLineWidth(args[0]);
+                break;
 
-          case _util.OPS.setLineJoin:
-            this.setLineJoin(args[0]);
-            break;
+              case _util.OPS.setLineJoin:
+                this.setLineJoin(args[0]);
+                break;
 
-          case _util.OPS.setLineCap:
-            this.setLineCap(args[0]);
-            break;
+              case _util.OPS.setLineCap:
+                this.setLineCap(args[0]);
+                break;
 
-          case _util.OPS.setMiterLimit:
-            this.setMiterLimit(args[0]);
-            break;
+              case _util.OPS.setMiterLimit:
+                this.setMiterLimit(args[0]);
+                break;
 
-          case _util.OPS.setFillRGBColor:
-            this.setFillRGBColor(args[0], args[1], args[2]);
-            break;
+              case _util.OPS.setFillRGBColor:
+                this.setFillRGBColor(args[0], args[1], args[2]);
+                break;
 
-          case _util.OPS.setStrokeRGBColor:
-            this.setStrokeRGBColor(args[0], args[1], args[2]);
-            break;
+              case _util.OPS.setStrokeRGBColor:
+                this.setStrokeRGBColor(args[0], args[1], args[2]);
+                break;
 
-          case _util.OPS.setStrokeColorN:
-            this.setStrokeColorN(args);
-            break;
+              case _util.OPS.setStrokeColorN:
+                this.setStrokeColorN(args);
+                break;
 
-          case _util.OPS.setFillColorN:
-            this.setFillColorN(args);
-            break;
+              case _util.OPS.setFillColorN:
+                this.setFillColorN(args);
+                break;
 
-          case _util.OPS.shadingFill:
-            this.shadingFill(args[0]);
-            break;
+              case _util.OPS.shadingFill:
+                this.shadingFill(args[0]);
+                break;
 
-          case _util.OPS.setDash:
-            this.setDash(args[0], args[1]);
-            break;
+              case _util.OPS.setDash:
+                this.setDash(args[0], args[1]);
+                break;
 
-          case _util.OPS.setRenderingIntent:
-            this.setRenderingIntent(args[0]);
-            break;
+              case _util.OPS.setRenderingIntent:
+                this.setRenderingIntent(args[0]);
+                break;
 
-          case _util.OPS.setFlatness:
-            this.setFlatness(args[0]);
-            break;
+              case _util.OPS.setFlatness:
+                this.setFlatness(args[0]);
+                break;
 
-          case _util.OPS.setGState:
-            this.setGState(args[0]);
-            break;
+              case _util.OPS.setGState:
+                this.setGState(args[0]);
+                break;
 
-          case _util.OPS.fill:
-            this.fill();
-            break;
+              case _util.OPS.fill:
+                this.fill();
+                break;
 
-          case _util.OPS.eoFill:
-            this.eoFill();
-            break;
+              case _util.OPS.eoFill:
+                this.eoFill();
+                break;
 
-          case _util.OPS.stroke:
-            this.stroke();
-            break;
+              case _util.OPS.stroke:
+                this.stroke();
+                break;
 
-          case _util.OPS.fillStroke:
-            this.fillStroke();
-            break;
+              case _util.OPS.fillStroke:
+                this.fillStroke();
+                break;
 
-          case _util.OPS.eoFillStroke:
-            this.eoFillStroke();
-            break;
+              case _util.OPS.eoFillStroke:
+                this.eoFillStroke();
+                break;
 
-          case _util.OPS.clip:
-            this.clip("nonzero");
-            break;
+              case _util.OPS.clip:
+                this.clip("nonzero");
+                break;
 
-          case _util.OPS.eoClip:
-            this.clip("evenodd");
-            break;
+              case _util.OPS.eoClip:
+                this.clip("evenodd");
+                break;
 
-          case _util.OPS.paintSolidColorImageMask:
-            this.paintSolidColorImageMask();
-            break;
+              case _util.OPS.paintSolidColorImageMask:
+                this.paintSolidColorImageMask();
+                break;
 
-          case _util.OPS.paintImageXObject:
-            this.paintImageXObject(args[0]);
-            break;
+              case _util.OPS.paintImageXObject:
+                this.paintImageXObject(args[0]);
+                break;
 
-          case _util.OPS.paintInlineImageXObject:
-            this.paintInlineImageXObject(args[0]);
-            break;
+              case _util.OPS.paintInlineImageXObject:
+                this.paintInlineImageXObject(args[0]);
+                break;
 
-          case _util.OPS.paintImageMaskXObject:
-            this.paintImageMaskXObject(args[0]);
-            break;
+              case _util.OPS.paintImageMaskXObject:
+                this.paintImageMaskXObject(args[0]);
+                break;
 
-          case _util.OPS.paintFormXObjectBegin:
-            this.paintFormXObjectBegin(args[0], args[1]);
-            break;
+              case _util.OPS.paintFormXObjectBegin:
+                this.paintFormXObjectBegin(args[0], args[1]);
+                break;
 
-          case _util.OPS.paintFormXObjectEnd:
-            this.paintFormXObjectEnd();
-            break;
+              case _util.OPS.paintFormXObjectEnd:
+                this.paintFormXObjectEnd();
+                break;
 
-          case _util.OPS.closePath:
-            this.closePath();
-            break;
+              case _util.OPS.closePath:
+                this.closePath();
+                break;
 
-          case _util.OPS.closeStroke:
-            this.closeStroke();
-            break;
+              case _util.OPS.closeStroke:
+                this.closeStroke();
+                break;
 
-          case _util.OPS.closeFillStroke:
-            this.closeFillStroke();
-            break;
+              case _util.OPS.closeFillStroke:
+                this.closeFillStroke();
+                break;
 
-          case _util.OPS.closeEOFillStroke:
-            this.closeEOFillStroke();
-            break;
+              case _util.OPS.closeEOFillStroke:
+                this.closeEOFillStroke();
+                break;
 
-          case _util.OPS.nextLine:
-            this.nextLine();
-            break;
+              case _util.OPS.nextLine:
+                this.nextLine();
+                break;
 
-          case _util.OPS.transform:
-            this.transform(args[0], args[1], args[2], args[3], args[4], args[5]);
-            break;
+              case _util.OPS.transform:
+                this.transform(args[0], args[1], args[2], args[3], args[4], args[5]);
+                break;
 
-          case _util.OPS.constructPath:
-            this.constructPath(args[0], args[1]);
-            break;
+              case _util.OPS.constructPath:
+                this.constructPath(args[0], args[1]);
+                break;
 
-          case _util.OPS.endPath:
-            this.endPath();
-            break;
+              case _util.OPS.endPath:
+                this.endPath();
+                break;
 
-          case 92:
-            this.group(opTreeElement.items);
-            break;
+              case 92:
+                this.group(opTreeElement.items);
+                break;
 
-          default:
-            (0, _util.warn)(`Unimplemented operator ${fn}`);
-            break;
+              default:
+                (0, _util.warn)("Unimplemented operator ".concat(fn));
+                break;
+            }
+          }
+        } catch (err) {
+          _iterator3.e(err);
+        } finally {
+          _iterator3.f();
         }
       }
-    }
+    }, {
+      key: "setWordSpacing",
+      value: function setWordSpacing(wordSpacing) {
+        this.current.wordSpacing = wordSpacing;
+      }
+    }, {
+      key: "setCharSpacing",
+      value: function setCharSpacing(charSpacing) {
+        this.current.charSpacing = charSpacing;
+      }
+    }, {
+      key: "nextLine",
+      value: function nextLine() {
+        this.moveText(0, this.current.leading);
+      }
+    }, {
+      key: "setTextMatrix",
+      value: function setTextMatrix(a, b, c, d, e, f) {
+        var current = this.current;
+        current.textMatrix = current.lineMatrix = [a, b, c, d, e, f];
+        current.textMatrixScale = Math.sqrt(a * a + b * b);
+        current.x = current.lineX = 0;
+        current.y = current.lineY = 0;
+        current.xcoords = [];
+        current.ycoords = [];
+        current.tspan = this.svgFactory.createElement("svg:tspan");
+        current.tspan.setAttributeNS(null, "font-family", current.fontFamily);
+        current.tspan.setAttributeNS(null, "font-size", "".concat(pf(current.fontSize), "px"));
+        current.tspan.setAttributeNS(null, "y", pf(-current.y));
+        current.txtElement = this.svgFactory.createElement("svg:text");
+        current.txtElement.appendChild(current.tspan);
+      }
+    }, {
+      key: "beginText",
+      value: function beginText() {
+        var current = this.current;
+        current.x = current.lineX = 0;
+        current.y = current.lineY = 0;
+        current.textMatrix = _util.IDENTITY_MATRIX;
+        current.lineMatrix = _util.IDENTITY_MATRIX;
+        current.textMatrixScale = 1;
+        current.tspan = this.svgFactory.createElement("svg:tspan");
+        current.txtElement = this.svgFactory.createElement("svg:text");
+        current.txtgrp = this.svgFactory.createElement("svg:g");
+        current.xcoords = [];
+        current.ycoords = [];
+      }
+    }, {
+      key: "moveText",
+      value: function moveText(x, y) {
+        var current = this.current;
+        current.x = current.lineX += x;
+        current.y = current.lineY += y;
+        current.xcoords = [];
+        current.ycoords = [];
+        current.tspan = this.svgFactory.createElement("svg:tspan");
+        current.tspan.setAttributeNS(null, "font-family", current.fontFamily);
+        current.tspan.setAttributeNS(null, "font-size", "".concat(pf(current.fontSize), "px"));
+        current.tspan.setAttributeNS(null, "y", pf(-current.y));
+      }
+    }, {
+      key: "showText",
+      value: function showText(glyphs) {
+        var current = this.current;
+        var font = current.font;
+        var fontSize = current.fontSize;
 
-    setWordSpacing(wordSpacing) {
-      this.current.wordSpacing = wordSpacing;
-    }
+        if (fontSize === 0) {
+          return;
+        }
 
-    setCharSpacing(charSpacing) {
-      this.current.charSpacing = charSpacing;
-    }
+        var fontSizeScale = current.fontSizeScale;
+        var charSpacing = current.charSpacing;
+        var wordSpacing = current.wordSpacing;
+        var fontDirection = current.fontDirection;
+        var textHScale = current.textHScale * fontDirection;
+        var vertical = font.vertical;
+        var spacingDir = vertical ? 1 : -1;
+        var defaultVMetrics = font.defaultVMetrics;
+        var widthAdvanceScale = fontSize * current.fontMatrix[0];
+        var x = 0;
 
-    nextLine() {
-      this.moveText(0, this.current.leading);
-    }
+        var _iterator4 = _createForOfIteratorHelper(glyphs),
+            _step4;
 
-    setTextMatrix(a, b, c, d, e, f) {
-      const current = this.current;
-      current.textMatrix = current.lineMatrix = [a, b, c, d, e, f];
-      current.textMatrixScale = Math.sqrt(a * a + b * b);
-      current.x = current.lineX = 0;
-      current.y = current.lineY = 0;
-      current.xcoords = [];
-      current.ycoords = [];
-      current.tspan = this.svgFactory.createElement("svg:tspan");
-      current.tspan.setAttributeNS(null, "font-family", current.fontFamily);
-      current.tspan.setAttributeNS(null, "font-size", `${pf(current.fontSize)}px`);
-      current.tspan.setAttributeNS(null, "y", pf(-current.y));
-      current.txtElement = this.svgFactory.createElement("svg:text");
-      current.txtElement.appendChild(current.tspan);
-    }
-
-    beginText() {
-      const current = this.current;
-      current.x = current.lineX = 0;
-      current.y = current.lineY = 0;
-      current.textMatrix = _util.IDENTITY_MATRIX;
-      current.lineMatrix = _util.IDENTITY_MATRIX;
-      current.textMatrixScale = 1;
-      current.tspan = this.svgFactory.createElement("svg:tspan");
-      current.txtElement = this.svgFactory.createElement("svg:text");
-      current.txtgrp = this.svgFactory.createElement("svg:g");
-      current.xcoords = [];
-      current.ycoords = [];
-    }
-
-    moveText(x, y) {
-      const current = this.current;
-      current.x = current.lineX += x;
-      current.y = current.lineY += y;
-      current.xcoords = [];
-      current.ycoords = [];
-      current.tspan = this.svgFactory.createElement("svg:tspan");
-      current.tspan.setAttributeNS(null, "font-family", current.fontFamily);
-      current.tspan.setAttributeNS(null, "font-size", `${pf(current.fontSize)}px`);
-      current.tspan.setAttributeNS(null, "y", pf(-current.y));
-    }
-
-    showText(glyphs) {
-      const current = this.current;
-      const font = current.font;
-      const fontSize = current.fontSize;
+        try {
+          for (_iterator4.s(); !(_step4 = _iterator4.n()).done;) {
+            var glyph = _step4.value;
+
+            if (glyph === null) {
+              x += fontDirection * wordSpacing;
+              continue;
+            } else if ((0, _util.isNum)(glyph)) {
+              x += spacingDir * glyph * fontSize / 1000;
+              continue;
+            }
 
-      if (fontSize === 0) {
-        return;
-      }
+            var spacing = (glyph.isSpace ? wordSpacing : 0) + charSpacing;
+            var character = glyph.fontChar;
+            var scaledX = void 0,
+                scaledY = void 0;
+            var width = glyph.width;
+
+            if (vertical) {
+              var vx = void 0;
+              var vmetric = glyph.vmetric || defaultVMetrics;
+              vx = glyph.vmetric ? vmetric[1] : width * 0.5;
+              vx = -vx * widthAdvanceScale;
+              var vy = vmetric[2] * widthAdvanceScale;
+              width = vmetric ? -vmetric[0] : width;
+              scaledX = vx / fontSizeScale;
+              scaledY = (x + vy) / fontSizeScale;
+            } else {
+              scaledX = x / fontSizeScale;
+              scaledY = 0;
+            }
 
-      const fontSizeScale = current.fontSizeScale;
-      const charSpacing = current.charSpacing;
-      const wordSpacing = current.wordSpacing;
-      const fontDirection = current.fontDirection;
-      const textHScale = current.textHScale * fontDirection;
-      const vertical = font.vertical;
-      const spacingDir = vertical ? 1 : -1;
-      const defaultVMetrics = font.defaultVMetrics;
-      const widthAdvanceScale = fontSize * current.fontMatrix[0];
-      let x = 0;
-
-      for (const glyph of glyphs) {
-        if (glyph === null) {
-          x += fontDirection * wordSpacing;
-          continue;
-        } else if ((0, _util.isNum)(glyph)) {
-          x += spacingDir * glyph * fontSize / 1000;
-          continue;
-        }
+            if (glyph.isInFont || font.missingFile) {
+              current.xcoords.push(current.x + scaledX);
 
-        const spacing = (glyph.isSpace ? wordSpacing : 0) + charSpacing;
-        const character = glyph.fontChar;
-        let scaledX, scaledY;
-        let width = glyph.width;
+              if (vertical) {
+                current.ycoords.push(-current.y + scaledY);
+              }
 
-        if (vertical) {
-          let vx;
-          const vmetric = glyph.vmetric || defaultVMetrics;
-          vx = glyph.vmetric ? vmetric[1] : width * 0.5;
-          vx = -vx * widthAdvanceScale;
-          const vy = vmetric[2] * widthAdvanceScale;
-          width = vmetric ? -vmetric[0] : width;
-          scaledX = vx / fontSizeScale;
-          scaledY = (x + vy) / fontSizeScale;
-        } else {
-          scaledX = x / fontSizeScale;
-          scaledY = 0;
-        }
+              current.tspan.textContent += character;
+            } else {}
 
-        if (glyph.isInFont || font.missingFile) {
-          current.xcoords.push(current.x + scaledX);
+            var charWidth = void 0;
 
-          if (vertical) {
-            current.ycoords.push(-current.y + scaledY);
-          }
+            if (vertical) {
+              charWidth = width * widthAdvanceScale - spacing * fontDirection;
+            } else {
+              charWidth = width * widthAdvanceScale + spacing * fontDirection;
+            }
 
-          current.tspan.textContent += character;
-        } else {}
+            x += charWidth;
+          }
+        } catch (err) {
+          _iterator4.e(err);
+        } finally {
+          _iterator4.f();
+        }
 
-        let charWidth;
+        current.tspan.setAttributeNS(null, "x", current.xcoords.map(pf).join(" "));
 
         if (vertical) {
-          charWidth = width * widthAdvanceScale - spacing * fontDirection;
+          current.tspan.setAttributeNS(null, "y", current.ycoords.map(pf).join(" "));
         } else {
-          charWidth = width * widthAdvanceScale + spacing * fontDirection;
+          current.tspan.setAttributeNS(null, "y", pf(-current.y));
         }
 
-        x += charWidth;
-      }
+        if (vertical) {
+          current.y -= x;
+        } else {
+          current.x += x * textHScale;
+        }
 
-      current.tspan.setAttributeNS(null, "x", current.xcoords.map(pf).join(" "));
+        current.tspan.setAttributeNS(null, "font-family", current.fontFamily);
+        current.tspan.setAttributeNS(null, "font-size", "".concat(pf(current.fontSize), "px"));
 
-      if (vertical) {
-        current.tspan.setAttributeNS(null, "y", current.ycoords.map(pf).join(" "));
-      } else {
-        current.tspan.setAttributeNS(null, "y", pf(-current.y));
-      }
+        if (current.fontStyle !== SVG_DEFAULTS.fontStyle) {
+          current.tspan.setAttributeNS(null, "font-style", current.fontStyle);
+        }
 
-      if (vertical) {
-        current.y -= x;
-      } else {
-        current.x += x * textHScale;
-      }
+        if (current.fontWeight !== SVG_DEFAULTS.fontWeight) {
+          current.tspan.setAttributeNS(null, "font-weight", current.fontWeight);
+        }
 
-      current.tspan.setAttributeNS(null, "font-family", current.fontFamily);
-      current.tspan.setAttributeNS(null, "font-size", `${pf(current.fontSize)}px`);
+        var fillStrokeMode = current.textRenderingMode & _util.TextRenderingMode.FILL_STROKE_MASK;
 
-      if (current.fontStyle !== SVG_DEFAULTS.fontStyle) {
-        current.tspan.setAttributeNS(null, "font-style", current.fontStyle);
-      }
+        if (fillStrokeMode === _util.TextRenderingMode.FILL || fillStrokeMode === _util.TextRenderingMode.FILL_STROKE) {
+          if (current.fillColor !== SVG_DEFAULTS.fillColor) {
+            current.tspan.setAttributeNS(null, "fill", current.fillColor);
+          }
 
-      if (current.fontWeight !== SVG_DEFAULTS.fontWeight) {
-        current.tspan.setAttributeNS(null, "font-weight", current.fontWeight);
-      }
+          if (current.fillAlpha < 1) {
+            current.tspan.setAttributeNS(null, "fill-opacity", current.fillAlpha);
+          }
+        } else if (current.textRenderingMode === _util.TextRenderingMode.ADD_TO_PATH) {
+          current.tspan.setAttributeNS(null, "fill", "transparent");
+        } else {
+          current.tspan.setAttributeNS(null, "fill", "none");
+        }
 
-      const fillStrokeMode = current.textRenderingMode & _util.TextRenderingMode.FILL_STROKE_MASK;
+        if (fillStrokeMode === _util.TextRenderingMode.STROKE || fillStrokeMode === _util.TextRenderingMode.FILL_STROKE) {
+          var lineWidthScale = 1 / (current.textMatrixScale || 1);
 
-      if (fillStrokeMode === _util.TextRenderingMode.FILL || fillStrokeMode === _util.TextRenderingMode.FILL_STROKE) {
-        if (current.fillColor !== SVG_DEFAULTS.fillColor) {
-          current.tspan.setAttributeNS(null, "fill", current.fillColor);
+          this._setStrokeAttributes(current.tspan, lineWidthScale);
         }
 
-        if (current.fillAlpha < 1) {
-          current.tspan.setAttributeNS(null, "fill-opacity", current.fillAlpha);
+        var textMatrix = current.textMatrix;
+
+        if (current.textRise !== 0) {
+          textMatrix = textMatrix.slice();
+          textMatrix[5] += current.textRise;
         }
-      } else if (current.textRenderingMode === _util.TextRenderingMode.ADD_TO_PATH) {
-        current.tspan.setAttributeNS(null, "fill", "transparent");
-      } else {
-        current.tspan.setAttributeNS(null, "fill", "none");
-      }
 
-      if (fillStrokeMode === _util.TextRenderingMode.STROKE || fillStrokeMode === _util.TextRenderingMode.FILL_STROKE) {
-        const lineWidthScale = 1 / (current.textMatrixScale || 1);
+        current.txtElement.setAttributeNS(null, "transform", "".concat(pm(textMatrix), " scale(").concat(pf(textHScale), ", -1)"));
+        current.txtElement.setAttributeNS(XML_NS, "xml:space", "preserve");
+        current.txtElement.appendChild(current.tspan);
+        current.txtgrp.appendChild(current.txtElement);
 
-        this._setStrokeAttributes(current.tspan, lineWidthScale);
+        this._ensureTransformGroup().appendChild(current.txtElement);
+      }
+    }, {
+      key: "setLeadingMoveText",
+      value: function setLeadingMoveText(x, y) {
+        this.setLeading(-y);
+        this.moveText(x, y);
       }
+    }, {
+      key: "addFontStyle",
+      value: function addFontStyle(fontObj) {
+        if (!fontObj.data) {
+          throw new Error("addFontStyle: No font data available, " + 'ensure that the "fontExtraProperties" API parameter is set.');
+        }
 
-      let textMatrix = current.textMatrix;
+        if (!this.cssStyle) {
+          this.cssStyle = this.svgFactory.createElement("svg:style");
+          this.cssStyle.setAttributeNS(null, "type", "text/css");
+          this.defs.appendChild(this.cssStyle);
+        }
 
-      if (current.textRise !== 0) {
-        textMatrix = textMatrix.slice();
-        textMatrix[5] += current.textRise;
+        var url = (0, _util.createObjectURL)(fontObj.data, fontObj.mimetype, this.forceDataSchema);
+        this.cssStyle.textContent += "@font-face { font-family: \"".concat(fontObj.loadedName, "\";") + " src: url(".concat(url, "); }\n");
       }
+    }, {
+      key: "setFont",
+      value: function setFont(details) {
+        var current = this.current;
+        var fontObj = this.commonObjs.get(details[0]);
+        var size = details[1];
+        current.font = fontObj;
+
+        if (this.embedFonts && !fontObj.missingFile && !this.embeddedFonts[fontObj.loadedName]) {
+          this.addFontStyle(fontObj);
+          this.embeddedFonts[fontObj.loadedName] = fontObj;
+        }
 
-      current.txtElement.setAttributeNS(null, "transform", `${pm(textMatrix)} scale(${pf(textHScale)}, -1)`);
-      current.txtElement.setAttributeNS(XML_NS, "xml:space", "preserve");
-      current.txtElement.appendChild(current.tspan);
-      current.txtgrp.appendChild(current.txtElement);
+        current.fontMatrix = fontObj.fontMatrix ? fontObj.fontMatrix : _util.FONT_IDENTITY_MATRIX;
+        var bold = "normal";
 
-      this._ensureTransformGroup().appendChild(current.txtElement);
-    }
+        if (fontObj.black) {
+          bold = "900";
+        } else if (fontObj.bold) {
+          bold = "bold";
+        }
 
-    setLeadingMoveText(x, y) {
-      this.setLeading(-y);
-      this.moveText(x, y);
-    }
+        var italic = fontObj.italic ? "italic" : "normal";
 
-    addFontStyle(fontObj) {
-      if (!fontObj.data) {
-        throw new Error("addFontStyle: No font data available, " + 'ensure that the "fontExtraProperties" API parameter is set.');
-      }
+        if (size < 0) {
+          size = -size;
+          current.fontDirection = -1;
+        } else {
+          current.fontDirection = 1;
+        }
 
-      if (!this.cssStyle) {
-        this.cssStyle = this.svgFactory.createElement("svg:style");
-        this.cssStyle.setAttributeNS(null, "type", "text/css");
-        this.defs.appendChild(this.cssStyle);
+        current.fontSize = size;
+        current.fontFamily = fontObj.loadedName;
+        current.fontWeight = bold;
+        current.fontStyle = italic;
+        current.tspan = this.svgFactory.createElement("svg:tspan");
+        current.tspan.setAttributeNS(null, "y", pf(-current.y));
+        current.xcoords = [];
+        current.ycoords = [];
       }
-
-      const url = (0, _util.createObjectURL)(fontObj.data, fontObj.mimetype, this.forceDataSchema);
-      this.cssStyle.textContent += `@font-face { font-family: "${fontObj.loadedName}";` + ` src: url(${url}); }\n`;
-    }
-
-    setFont(details) {
-      const current = this.current;
-      const fontObj = this.commonObjs.get(details[0]);
-      let size = details[1];
-      current.font = fontObj;
-
-      if (this.embedFonts && !fontObj.missingFile && !this.embeddedFonts[fontObj.loadedName]) {
-        this.addFontStyle(fontObj);
-        this.embeddedFonts[fontObj.loadedName] = fontObj;
+    }, {
+      key: "endText",
+      value: function endText() {
+        var current = this.current;
+
+        if (current.textRenderingMode & _util.TextRenderingMode.ADD_TO_PATH_FLAG && current.txtElement && current.txtElement.hasChildNodes()) {
+          current.element = current.txtElement;
+          this.clip("nonzero");
+          this.endPath();
+        }
       }
-
-      current.fontMatrix = fontObj.fontMatrix ? fontObj.fontMatrix : _util.FONT_IDENTITY_MATRIX;
-      let bold = "normal";
-
-      if (fontObj.black) {
-        bold = "900";
-      } else if (fontObj.bold) {
-        bold = "bold";
+    }, {
+      key: "setLineWidth",
+      value: function setLineWidth(width) {
+        if (width > 0) {
+          this.current.lineWidth = width;
+        }
       }
-
-      const italic = fontObj.italic ? "italic" : "normal";
-
-      if (size < 0) {
-        size = -size;
-        current.fontDirection = -1;
-      } else {
-        current.fontDirection = 1;
+    }, {
+      key: "setLineCap",
+      value: function setLineCap(style) {
+        this.current.lineCap = LINE_CAP_STYLES[style];
       }
-
-      current.fontSize = size;
-      current.fontFamily = fontObj.loadedName;
-      current.fontWeight = bold;
-      current.fontStyle = italic;
-      current.tspan = this.svgFactory.createElement("svg:tspan");
-      current.tspan.setAttributeNS(null, "y", pf(-current.y));
-      current.xcoords = [];
-      current.ycoords = [];
-    }
-
-    endText() {
-      const current = this.current;
-
-      if (current.textRenderingMode & _util.TextRenderingMode.ADD_TO_PATH_FLAG && current.txtElement && current.txtElement.hasChildNodes()) {
-        current.element = current.txtElement;
-        this.clip("nonzero");
-        this.endPath();
+    }, {
+      key: "setLineJoin",
+      value: function setLineJoin(style) {
+        this.current.lineJoin = LINE_JOIN_STYLES[style];
       }
-    }
-
-    setLineWidth(width) {
-      if (width > 0) {
-        this.current.lineWidth = width;
+    }, {
+      key: "setMiterLimit",
+      value: function setMiterLimit(limit) {
+        this.current.miterLimit = limit;
       }
-    }
-
-    setLineCap(style) {
-      this.current.lineCap = LINE_CAP_STYLES[style];
-    }
-
-    setLineJoin(style) {
-      this.current.lineJoin = LINE_JOIN_STYLES[style];
-    }
-
-    setMiterLimit(limit) {
-      this.current.miterLimit = limit;
-    }
-
-    setStrokeAlpha(strokeAlpha) {
-      this.current.strokeAlpha = strokeAlpha;
-    }
-
-    setStrokeRGBColor(r, g, b) {
-      this.current.strokeColor = _util.Util.makeCssRgb(r, g, b);
-    }
-
-    setFillAlpha(fillAlpha) {
-      this.current.fillAlpha = fillAlpha;
-    }
-
-    setFillRGBColor(r, g, b) {
-      this.current.fillColor = _util.Util.makeCssRgb(r, g, b);
-      this.current.tspan = this.svgFactory.createElement("svg:tspan");
-      this.current.xcoords = [];
-      this.current.ycoords = [];
-    }
-
-    setStrokeColorN(args) {
-      this.current.strokeColor = this._makeColorN_Pattern(args);
-    }
-
-    setFillColorN(args) {
-      this.current.fillColor = this._makeColorN_Pattern(args);
-    }
-
-    shadingFill(args) {
-      const width = this.viewport.width;
-      const height = this.viewport.height;
+    }, {
+      key: "setStrokeAlpha",
+      value: function setStrokeAlpha(strokeAlpha) {
+        this.current.strokeAlpha = strokeAlpha;
+      }
+    }, {
+      key: "setStrokeRGBColor",
+      value: function setStrokeRGBColor(r, g, b) {
+        this.current.strokeColor = _util.Util.makeCssRgb(r, g, b);
+      }
+    }, {
+      key: "setFillAlpha",
+      value: function setFillAlpha(fillAlpha) {
+        this.current.fillAlpha = fillAlpha;
+      }
+    }, {
+      key: "setFillRGBColor",
+      value: function setFillRGBColor(r, g, b) {
+        this.current.fillColor = _util.Util.makeCssRgb(r, g, b);
+        this.current.tspan = this.svgFactory.createElement("svg:tspan");
+        this.current.xcoords = [];
+        this.current.ycoords = [];
+      }
+    }, {
+      key: "setStrokeColorN",
+      value: function setStrokeColorN(args) {
+        this.current.strokeColor = this._makeColorN_Pattern(args);
+      }
+    }, {
+      key: "setFillColorN",
+      value: function setFillColorN(args) {
+        this.current.fillColor = this._makeColorN_Pattern(args);
+      }
+    }, {
+      key: "shadingFill",
+      value: function shadingFill(args) {
+        var width = this.viewport.width;
+        var height = this.viewport.height;
 
-      const inv = _util.Util.inverseTransform(this.transformMatrix);
+        var inv = _util.Util.inverseTransform(this.transformMatrix);
 
-      const bl = _util.Util.applyTransform([0, 0], inv);
+        var bl = _util.Util.applyTransform([0, 0], inv);
 
-      const br = _util.Util.applyTransform([0, height], inv);
+        var br = _util.Util.applyTransform([0, height], inv);
 
-      const ul = _util.Util.applyTransform([width, 0], inv);
+        var ul = _util.Util.applyTransform([width, 0], inv);
 
-      const ur = _util.Util.applyTransform([width, height], inv);
+        var ur = _util.Util.applyTransform([width, height], inv);
 
-      const x0 = Math.min(bl[0], br[0], ul[0], ur[0]);
-      const y0 = Math.min(bl[1], br[1], ul[1], ur[1]);
-      const x1 = Math.max(bl[0], br[0], ul[0], ur[0]);
-      const y1 = Math.max(bl[1], br[1], ul[1], ur[1]);
-      const rect = this.svgFactory.createElement("svg:rect");
-      rect.setAttributeNS(null, "x", x0);
-      rect.setAttributeNS(null, "y", y0);
-      rect.setAttributeNS(null, "width", x1 - x0);
-      rect.setAttributeNS(null, "height", y1 - y0);
-      rect.setAttributeNS(null, "fill", this._makeShadingPattern(args));
+        var x0 = Math.min(bl[0], br[0], ul[0], ur[0]);
+        var y0 = Math.min(bl[1], br[1], ul[1], ur[1]);
+        var x1 = Math.max(bl[0], br[0], ul[0], ur[0]);
+        var y1 = Math.max(bl[1], br[1], ul[1], ur[1]);
+        var rect = this.svgFactory.createElement("svg:rect");
+        rect.setAttributeNS(null, "x", x0);
+        rect.setAttributeNS(null, "y", y0);
+        rect.setAttributeNS(null, "width", x1 - x0);
+        rect.setAttributeNS(null, "height", y1 - y0);
+        rect.setAttributeNS(null, "fill", this._makeShadingPattern(args));
+
+        if (this.current.fillAlpha < 1) {
+          rect.setAttributeNS(null, "fill-opacity", this.current.fillAlpha);
+        }
 
-      if (this.current.fillAlpha < 1) {
-        rect.setAttributeNS(null, "fill-opacity", this.current.fillAlpha);
+        this._ensureTransformGroup().appendChild(rect);
       }
+    }, {
+      key: "_makeColorN_Pattern",
+      value: function _makeColorN_Pattern(args) {
+        if (args[0] === "TilingPattern") {
+          return this._makeTilingPattern(args);
+        }
 
-      this._ensureTransformGroup().appendChild(rect);
-    }
-
-    _makeColorN_Pattern(args) {
-      if (args[0] === "TilingPattern") {
-        return this._makeTilingPattern(args);
+        return this._makeShadingPattern(args);
       }
+    }, {
+      key: "_makeTilingPattern",
+      value: function _makeTilingPattern(args) {
+        var color = args[1];
+        var operatorList = args[2];
+        var matrix = args[3] || _util.IDENTITY_MATRIX;
+
+        var _args$ = _slicedToArray(args[4], 4),
+            x0 = _args$[0],
+            y0 = _args$[1],
+            x1 = _args$[2],
+            y1 = _args$[3];
+
+        var xstep = args[5];
+        var ystep = args[6];
+        var paintType = args[7];
+        var tilingId = "shading".concat(shadingCount++);
+
+        var _Util$applyTransform = _util.Util.applyTransform([x0, y0], matrix),
+            _Util$applyTransform2 = _slicedToArray(_Util$applyTransform, 2),
+            tx0 = _Util$applyTransform2[0],
+            ty0 = _Util$applyTransform2[1];
+
+        var _Util$applyTransform3 = _util.Util.applyTransform([x1, y1], matrix),
+            _Util$applyTransform4 = _slicedToArray(_Util$applyTransform3, 2),
+            tx1 = _Util$applyTransform4[0],
+            ty1 = _Util$applyTransform4[1];
+
+        var _Util$singularValueDe = _util.Util.singularValueDecompose2dScale(matrix),
+            _Util$singularValueDe2 = _slicedToArray(_Util$singularValueDe, 2),
+            xscale = _Util$singularValueDe2[0],
+            yscale = _Util$singularValueDe2[1];
+
+        var txstep = xstep * xscale;
+        var tystep = ystep * yscale;
+        var tiling = this.svgFactory.createElement("svg:pattern");
+        tiling.setAttributeNS(null, "id", tilingId);
+        tiling.setAttributeNS(null, "patternUnits", "userSpaceOnUse");
+        tiling.setAttributeNS(null, "width", txstep);
+        tiling.setAttributeNS(null, "height", tystep);
+        tiling.setAttributeNS(null, "x", "".concat(tx0));
+        tiling.setAttributeNS(null, "y", "".concat(ty0));
+        var svg = this.svg;
+        var transformMatrix = this.transformMatrix;
+        var fillColor = this.current.fillColor;
+        var strokeColor = this.current.strokeColor;
+        var bbox = this.svgFactory.create(tx1 - tx0, ty1 - ty0);
+        this.svg = bbox;
+        this.transformMatrix = matrix;
+
+        if (paintType === 2) {
+          var cssColor = _util.Util.makeCssRgb.apply(_util.Util, _toConsumableArray(color));
+
+          this.current.fillColor = cssColor;
+          this.current.strokeColor = cssColor;
+        }
 
-      return this._makeShadingPattern(args);
-    }
-
-    _makeTilingPattern(args) {
-      const color = args[1];
-      const operatorList = args[2];
-      const matrix = args[3] || _util.IDENTITY_MATRIX;
-      const [x0, y0, x1, y1] = args[4];
-      const xstep = args[5];
-      const ystep = args[6];
-      const paintType = args[7];
-      const tilingId = `shading${shadingCount++}`;
+        this.executeOpTree(this.convertOpList(operatorList));
+        this.svg = svg;
+        this.transformMatrix = transformMatrix;
+        this.current.fillColor = fillColor;
+        this.current.strokeColor = strokeColor;
+        tiling.appendChild(bbox.childNodes[0]);
+        this.defs.appendChild(tiling);
+        return "url(#".concat(tilingId, ")");
+      }
+    }, {
+      key: "_makeShadingPattern",
+      value: function _makeShadingPattern(args) {
+        switch (args[0]) {
+          case "RadialAxial":
+            var shadingId = "shading".concat(shadingCount++);
+            var colorStops = args[3];
+            var gradient;
+
+            switch (args[1]) {
+              case "axial":
+                var point0 = args[4];
+                var point1 = args[5];
+                gradient = this.svgFactory.createElement("svg:linearGradient");
+                gradient.setAttributeNS(null, "id", shadingId);
+                gradient.setAttributeNS(null, "gradientUnits", "userSpaceOnUse");
+                gradient.setAttributeNS(null, "x1", point0[0]);
+                gradient.setAttributeNS(null, "y1", point0[1]);
+                gradient.setAttributeNS(null, "x2", point1[0]);
+                gradient.setAttributeNS(null, "y2", point1[1]);
+                break;
+
+              case "radial":
+                var focalPoint = args[4];
+                var circlePoint = args[5];
+                var focalRadius = args[6];
+                var circleRadius = args[7];
+                gradient = this.svgFactory.createElement("svg:radialGradient");
+                gradient.setAttributeNS(null, "id", shadingId);
+                gradient.setAttributeNS(null, "gradientUnits", "userSpaceOnUse");
+                gradient.setAttributeNS(null, "cx", circlePoint[0]);
+                gradient.setAttributeNS(null, "cy", circlePoint[1]);
+                gradient.setAttributeNS(null, "r", circleRadius);
+                gradient.setAttributeNS(null, "fx", focalPoint[0]);
+                gradient.setAttributeNS(null, "fy", focalPoint[1]);
+                gradient.setAttributeNS(null, "fr", focalRadius);
+                break;
+
+              default:
+                throw new Error("Unknown RadialAxial type: ".concat(args[1]));
+            }
 
-      const [tx0, ty0] = _util.Util.applyTransform([x0, y0], matrix);
+            var _iterator5 = _createForOfIteratorHelper(colorStops),
+                _step5;
 
-      const [tx1, ty1] = _util.Util.applyTransform([x1, y1], matrix);
+            try {
+              for (_iterator5.s(); !(_step5 = _iterator5.n()).done;) {
+                var colorStop = _step5.value;
+                var stop = this.svgFactory.createElement("svg:stop");
+                stop.setAttributeNS(null, "offset", colorStop[0]);
+                stop.setAttributeNS(null, "stop-color", colorStop[1]);
+                gradient.appendChild(stop);
+              }
+            } catch (err) {
+              _iterator5.e(err);
+            } finally {
+              _iterator5.f();
+            }
 
-      const [xscale, yscale] = _util.Util.singularValueDecompose2dScale(matrix);
+            this.defs.appendChild(gradient);
+            return "url(#".concat(shadingId, ")");
 
-      const txstep = xstep * xscale;
-      const tystep = ystep * yscale;
-      const tiling = this.svgFactory.createElement("svg:pattern");
-      tiling.setAttributeNS(null, "id", tilingId);
-      tiling.setAttributeNS(null, "patternUnits", "userSpaceOnUse");
-      tiling.setAttributeNS(null, "width", txstep);
-      tiling.setAttributeNS(null, "height", tystep);
-      tiling.setAttributeNS(null, "x", `${tx0}`);
-      tiling.setAttributeNS(null, "y", `${ty0}`);
-      const svg = this.svg;
-      const transformMatrix = this.transformMatrix;
-      const fillColor = this.current.fillColor;
-      const strokeColor = this.current.strokeColor;
-      const bbox = this.svgFactory.create(tx1 - tx0, ty1 - ty0);
-      this.svg = bbox;
-      this.transformMatrix = matrix;
+          case "Mesh":
+            (0, _util.warn)("Unimplemented pattern Mesh");
+            return null;
 
-      if (paintType === 2) {
-        const cssColor = _util.Util.makeCssRgb(...color);
+          case "Dummy":
+            return "hotpink";
 
-        this.current.fillColor = cssColor;
-        this.current.strokeColor = cssColor;
+          default:
+            throw new Error("Unknown IR type: ".concat(args[0]));
+        }
       }
+    }, {
+      key: "setDash",
+      value: function setDash(dashArray, dashPhase) {
+        this.current.dashArray = dashArray;
+        this.current.dashPhase = dashPhase;
+      }
+    }, {
+      key: "constructPath",
+      value: function constructPath(ops, args) {
+        var current = this.current;
+        var x = current.x,
+            y = current.y;
+        var d = [];
+        var j = 0;
 
-      this.executeOpTree(this.convertOpList(operatorList));
-      this.svg = svg;
-      this.transformMatrix = transformMatrix;
-      this.current.fillColor = fillColor;
-      this.current.strokeColor = strokeColor;
-      tiling.appendChild(bbox.childNodes[0]);
-      this.defs.appendChild(tiling);
-      return `url(#${tilingId})`;
-    }
-
-    _makeShadingPattern(args) {
-      switch (args[0]) {
-        case "RadialAxial":
-          const shadingId = `shading${shadingCount++}`;
-          const colorStops = args[3];
-          let gradient;
-
-          switch (args[1]) {
-            case "axial":
-              const point0 = args[4];
-              const point1 = args[5];
-              gradient = this.svgFactory.createElement("svg:linearGradient");
-              gradient.setAttributeNS(null, "id", shadingId);
-              gradient.setAttributeNS(null, "gradientUnits", "userSpaceOnUse");
-              gradient.setAttributeNS(null, "x1", point0[0]);
-              gradient.setAttributeNS(null, "y1", point0[1]);
-              gradient.setAttributeNS(null, "x2", point1[0]);
-              gradient.setAttributeNS(null, "y2", point1[1]);
-              break;
-
-            case "radial":
-              const focalPoint = args[4];
-              const circlePoint = args[5];
-              const focalRadius = args[6];
-              const circleRadius = args[7];
-              gradient = this.svgFactory.createElement("svg:radialGradient");
-              gradient.setAttributeNS(null, "id", shadingId);
-              gradient.setAttributeNS(null, "gradientUnits", "userSpaceOnUse");
-              gradient.setAttributeNS(null, "cx", circlePoint[0]);
-              gradient.setAttributeNS(null, "cy", circlePoint[1]);
-              gradient.setAttributeNS(null, "r", circleRadius);
-              gradient.setAttributeNS(null, "fx", focalPoint[0]);
-              gradient.setAttributeNS(null, "fy", focalPoint[1]);
-              gradient.setAttributeNS(null, "fr", focalRadius);
-              break;
-
-            default:
-              throw new Error(`Unknown RadialAxial type: ${args[1]}`);
-          }
+        var _iterator6 = _createForOfIteratorHelper(ops),
+            _step6;
 
-          for (const colorStop of colorStops) {
-            const stop = this.svgFactory.createElement("svg:stop");
-            stop.setAttributeNS(null, "offset", colorStop[0]);
-            stop.setAttributeNS(null, "stop-color", colorStop[1]);
-            gradient.appendChild(stop);
+        try {
+          for (_iterator6.s(); !(_step6 = _iterator6.n()).done;) {
+            var op = _step6.value;
+
+            switch (op | 0) {
+              case _util.OPS.rectangle:
+                x = args[j++];
+                y = args[j++];
+                var width = args[j++];
+                var height = args[j++];
+                var xw = x + width;
+                var yh = y + height;
+                d.push("M", pf(x), pf(y), "L", pf(xw), pf(y), "L", pf(xw), pf(yh), "L", pf(x), pf(yh), "Z");
+                break;
+
+              case _util.OPS.moveTo:
+                x = args[j++];
+                y = args[j++];
+                d.push("M", pf(x), pf(y));
+                break;
+
+              case _util.OPS.lineTo:
+                x = args[j++];
+                y = args[j++];
+                d.push("L", pf(x), pf(y));
+                break;
+
+              case _util.OPS.curveTo:
+                x = args[j + 4];
+                y = args[j + 5];
+                d.push("C", pf(args[j]), pf(args[j + 1]), pf(args[j + 2]), pf(args[j + 3]), pf(x), pf(y));
+                j += 6;
+                break;
+
+              case _util.OPS.curveTo2:
+                d.push("C", pf(x), pf(y), pf(args[j]), pf(args[j + 1]), pf(args[j + 2]), pf(args[j + 3]));
+                x = args[j + 2];
+                y = args[j + 3];
+                j += 4;
+                break;
+
+              case _util.OPS.curveTo3:
+                x = args[j + 2];
+                y = args[j + 3];
+                d.push("C", pf(args[j]), pf(args[j + 1]), pf(x), pf(y), pf(x), pf(y));
+                j += 4;
+                break;
+
+              case _util.OPS.closePath:
+                d.push("Z");
+                break;
+            }
           }
+        } catch (err) {
+          _iterator6.e(err);
+        } finally {
+          _iterator6.f();
+        }
 
-          this.defs.appendChild(gradient);
-          return `url(#${shadingId})`;
+        d = d.join(" ");
 
-        case "Mesh":
-          (0, _util.warn)("Unimplemented pattern Mesh");
-          return null;
+        if (current.path && ops.length > 0 && ops[0] !== _util.OPS.rectangle && ops[0] !== _util.OPS.moveTo) {
+          d = current.path.getAttributeNS(null, "d") + d;
+        } else {
+          current.path = this.svgFactory.createElement("svg:path");
 
-        case "Dummy":
-          return "hotpink";
+          this._ensureTransformGroup().appendChild(current.path);
+        }
 
-        default:
-          throw new Error(`Unknown IR type: ${args[0]}`);
+        current.path.setAttributeNS(null, "d", d);
+        current.path.setAttributeNS(null, "fill", "none");
+        current.element = current.path;
+        current.setCurrentPoint(x, y);
       }
-    }
-
-    setDash(dashArray, dashPhase) {
-      this.current.dashArray = dashArray;
-      this.current.dashPhase = dashPhase;
-    }
+    }, {
+      key: "endPath",
+      value: function endPath() {
+        var current = this.current;
+        current.path = null;
 
-    constructPath(ops, args) {
-      const current = this.current;
-      let x = current.x,
-          y = current.y;
-      let d = [];
-      let j = 0;
+        if (!this.pendingClip) {
+          return;
+        }
 
-      for (const op of ops) {
-        switch (op | 0) {
-          case _util.OPS.rectangle:
-            x = args[j++];
-            y = args[j++];
-            const width = args[j++];
-            const height = args[j++];
-            const xw = x + width;
-            const yh = y + height;
-            d.push("M", pf(x), pf(y), "L", pf(xw), pf(y), "L", pf(xw), pf(yh), "L", pf(x), pf(yh), "Z");
-            break;
+        if (!current.element) {
+          this.pendingClip = null;
+          return;
+        }
 
-          case _util.OPS.moveTo:
-            x = args[j++];
-            y = args[j++];
-            d.push("M", pf(x), pf(y));
-            break;
+        var clipId = "clippath".concat(clipCount++);
+        var clipPath = this.svgFactory.createElement("svg:clipPath");
+        clipPath.setAttributeNS(null, "id", clipId);
+        clipPath.setAttributeNS(null, "transform", pm(this.transformMatrix));
+        var clipElement = current.element.cloneNode(true);
 
-          case _util.OPS.lineTo:
-            x = args[j++];
-            y = args[j++];
-            d.push("L", pf(x), pf(y));
-            break;
+        if (this.pendingClip === "evenodd") {
+          clipElement.setAttributeNS(null, "clip-rule", "evenodd");
+        } else {
+          clipElement.setAttributeNS(null, "clip-rule", "nonzero");
+        }
 
-          case _util.OPS.curveTo:
-            x = args[j + 4];
-            y = args[j + 5];
-            d.push("C", pf(args[j]), pf(args[j + 1]), pf(args[j + 2]), pf(args[j + 3]), pf(x), pf(y));
-            j += 6;
-            break;
+        this.pendingClip = null;
+        clipPath.appendChild(clipElement);
+        this.defs.appendChild(clipPath);
 
-          case _util.OPS.curveTo2:
-            d.push("C", pf(x), pf(y), pf(args[j]), pf(args[j + 1]), pf(args[j + 2]), pf(args[j + 3]));
-            x = args[j + 2];
-            y = args[j + 3];
-            j += 4;
-            break;
+        if (current.activeClipUrl) {
+          current.clipGroup = null;
+          this.extraStack.forEach(function (prev) {
+            prev.clipGroup = null;
+          });
+          clipPath.setAttributeNS(null, "clip-path", current.activeClipUrl);
+        }
 
-          case _util.OPS.curveTo3:
-            x = args[j + 2];
-            y = args[j + 3];
-            d.push("C", pf(args[j]), pf(args[j + 1]), pf(x), pf(y), pf(x), pf(y));
-            j += 4;
-            break;
+        current.activeClipUrl = "url(#".concat(clipId, ")");
+        this.tgrp = null;
+      }
+    }, {
+      key: "clip",
+      value: function clip(type) {
+        this.pendingClip = type;
+      }
+    }, {
+      key: "closePath",
+      value: function closePath() {
+        var current = this.current;
 
-          case _util.OPS.closePath:
-            d.push("Z");
-            break;
+        if (current.path) {
+          var d = "".concat(current.path.getAttributeNS(null, "d"), "Z");
+          current.path.setAttributeNS(null, "d", d);
         }
       }
-
-      d = d.join(" ");
-
-      if (current.path && ops.length > 0 && ops[0] !== _util.OPS.rectangle && ops[0] !== _util.OPS.moveTo) {
-        d = current.path.getAttributeNS(null, "d") + d;
-      } else {
-        current.path = this.svgFactory.createElement("svg:path");
-
-        this._ensureTransformGroup().appendChild(current.path);
+    }, {
+      key: "setLeading",
+      value: function setLeading(leading) {
+        this.current.leading = -leading;
       }
-
-      current.path.setAttributeNS(null, "d", d);
-      current.path.setAttributeNS(null, "fill", "none");
-      current.element = current.path;
-      current.setCurrentPoint(x, y);
-    }
-
-    endPath() {
-      const current = this.current;
-      current.path = null;
-
-      if (!this.pendingClip) {
-        return;
+    }, {
+      key: "setTextRise",
+      value: function setTextRise(textRise) {
+        this.current.textRise = textRise;
       }
-
-      if (!current.element) {
-        this.pendingClip = null;
-        return;
+    }, {
+      key: "setTextRenderingMode",
+      value: function setTextRenderingMode(textRenderingMode) {
+        this.current.textRenderingMode = textRenderingMode;
       }
-
-      const clipId = `clippath${clipCount++}`;
-      const clipPath = this.svgFactory.createElement("svg:clipPath");
-      clipPath.setAttributeNS(null, "id", clipId);
-      clipPath.setAttributeNS(null, "transform", pm(this.transformMatrix));
-      const clipElement = current.element.cloneNode(true);
-
-      if (this.pendingClip === "evenodd") {
-        clipElement.setAttributeNS(null, "clip-rule", "evenodd");
-      } else {
-        clipElement.setAttributeNS(null, "clip-rule", "nonzero");
+    }, {
+      key: "setHScale",
+      value: function setHScale(scale) {
+        this.current.textHScale = scale / 100;
       }
+    }, {
+      key: "setRenderingIntent",
+      value: function setRenderingIntent(intent) {}
+    }, {
+      key: "setFlatness",
+      value: function setFlatness(flatness) {}
+    }, {
+      key: "setGState",
+      value: function setGState(states) {
+        var _iterator7 = _createForOfIteratorHelper(states),
+            _step7;
 
-      this.pendingClip = null;
-      clipPath.appendChild(clipElement);
-      this.defs.appendChild(clipPath);
-
-      if (current.activeClipUrl) {
-        current.clipGroup = null;
-        this.extraStack.forEach(function (prev) {
-          prev.clipGroup = null;
-        });
-        clipPath.setAttributeNS(null, "clip-path", current.activeClipUrl);
+        try {
+          for (_iterator7.s(); !(_step7 = _iterator7.n()).done;) {
+            var _step7$value = _slicedToArray(_step7.value, 2),
+                key = _step7$value[0],
+                value = _step7$value[1];
+
+            switch (key) {
+              case "LW":
+                this.setLineWidth(value);
+                break;
+
+              case "LC":
+                this.setLineCap(value);
+                break;
+
+              case "LJ":
+                this.setLineJoin(value);
+                break;
+
+              case "ML":
+                this.setMiterLimit(value);
+                break;
+
+              case "D":
+                this.setDash(value[0], value[1]);
+                break;
+
+              case "RI":
+                this.setRenderingIntent(value);
+                break;
+
+              case "FL":
+                this.setFlatness(value);
+                break;
+
+              case "Font":
+                this.setFont(value);
+                break;
+
+              case "CA":
+                this.setStrokeAlpha(value);
+                break;
+
+              case "ca":
+                this.setFillAlpha(value);
+                break;
+
+              default:
+                (0, _util.warn)("Unimplemented graphic state operator ".concat(key));
+                break;
+            }
+          }
+        } catch (err) {
+          _iterator7.e(err);
+        } finally {
+          _iterator7.f();
+        }
       }
-
-      current.activeClipUrl = `url(#${clipId})`;
-      this.tgrp = null;
-    }
-
-    clip(type) {
-      this.pendingClip = type;
-    }
-
-    closePath() {
-      const current = this.current;
-
-      if (current.path) {
-        const d = `${current.path.getAttributeNS(null, "d")}Z`;
-        current.path.setAttributeNS(null, "d", d);
+    }, {
+      key: "fill",
+      value: function fill() {
+        var current = this.current;
+
+        if (current.element) {
+          current.element.setAttributeNS(null, "fill", current.fillColor);
+          current.element.setAttributeNS(null, "fill-opacity", current.fillAlpha);
+          this.endPath();
+        }
       }
-    }
-
-    setLeading(leading) {
-      this.current.leading = -leading;
-    }
-
-    setTextRise(textRise) {
-      this.current.textRise = textRise;
-    }
-
-    setTextRenderingMode(textRenderingMode) {
-      this.current.textRenderingMode = textRenderingMode;
-    }
-
-    setHScale(scale) {
-      this.current.textHScale = scale / 100;
-    }
-
-    setRenderingIntent(intent) {}
-
-    setFlatness(flatness) {}
-
-    setGState(states) {
-      for (const [key, value] of states) {
-        switch (key) {
-          case "LW":
-            this.setLineWidth(value);
-            break;
-
-          case "LC":
-            this.setLineCap(value);
-            break;
-
-          case "LJ":
-            this.setLineJoin(value);
-            break;
-
-          case "ML":
-            this.setMiterLimit(value);
-            break;
-
-          case "D":
-            this.setDash(value[0], value[1]);
-            break;
-
-          case "RI":
-            this.setRenderingIntent(value);
-            break;
-
-          case "FL":
-            this.setFlatness(value);
-            break;
-
-          case "Font":
-            this.setFont(value);
-            break;
-
-          case "CA":
-            this.setStrokeAlpha(value);
-            break;
+    }, {
+      key: "stroke",
+      value: function stroke() {
+        var current = this.current;
 
-          case "ca":
-            this.setFillAlpha(value);
-            break;
+        if (current.element) {
+          this._setStrokeAttributes(current.element);
 
-          default:
-            (0, _util.warn)(`Unimplemented graphic state operator ${key}`);
-            break;
+          current.element.setAttributeNS(null, "fill", "none");
+          this.endPath();
         }
       }
-    }
-
-    fill() {
-      const current = this.current;
+    }, {
+      key: "_setStrokeAttributes",
+      value: function _setStrokeAttributes(element) {
+        var lineWidthScale = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : 1;
+        var current = this.current;
+        var dashArray = current.dashArray;
+
+        if (lineWidthScale !== 1 && dashArray.length > 0) {
+          dashArray = dashArray.map(function (value) {
+            return lineWidthScale * value;
+          });
+        }
 
-      if (current.element) {
-        current.element.setAttributeNS(null, "fill", current.fillColor);
-        current.element.setAttributeNS(null, "fill-opacity", current.fillAlpha);
-        this.endPath();
+        element.setAttributeNS(null, "stroke", current.strokeColor);
+        element.setAttributeNS(null, "stroke-opacity", current.strokeAlpha);
+        element.setAttributeNS(null, "stroke-miterlimit", pf(current.miterLimit));
+        element.setAttributeNS(null, "stroke-linecap", current.lineCap);
+        element.setAttributeNS(null, "stroke-linejoin", current.lineJoin);
+        element.setAttributeNS(null, "stroke-width", pf(lineWidthScale * current.lineWidth) + "px");
+        element.setAttributeNS(null, "stroke-dasharray", dashArray.map(pf).join(" "));
+        element.setAttributeNS(null, "stroke-dashoffset", pf(lineWidthScale * current.dashPhase) + "px");
       }
-    }
-
-    stroke() {
-      const current = this.current;
-
-      if (current.element) {
-        this._setStrokeAttributes(current.element);
+    }, {
+      key: "eoFill",
+      value: function eoFill() {
+        if (this.current.element) {
+          this.current.element.setAttributeNS(null, "fill-rule", "evenodd");
+        }
 
-        current.element.setAttributeNS(null, "fill", "none");
-        this.endPath();
+        this.fill();
       }
-    }
-
-    _setStrokeAttributes(element, lineWidthScale = 1) {
-      const current = this.current;
-      let dashArray = current.dashArray;
-
-      if (lineWidthScale !== 1 && dashArray.length > 0) {
-        dashArray = dashArray.map(function (value) {
-          return lineWidthScale * value;
-        });
+    }, {
+      key: "fillStroke",
+      value: function fillStroke() {
+        this.stroke();
+        this.fill();
       }
+    }, {
+      key: "eoFillStroke",
+      value: function eoFillStroke() {
+        if (this.current.element) {
+          this.current.element.setAttributeNS(null, "fill-rule", "evenodd");
+        }
 
-      element.setAttributeNS(null, "stroke", current.strokeColor);
-      element.setAttributeNS(null, "stroke-opacity", current.strokeAlpha);
-      element.setAttributeNS(null, "stroke-miterlimit", pf(current.miterLimit));
-      element.setAttributeNS(null, "stroke-linecap", current.lineCap);
-      element.setAttributeNS(null, "stroke-linejoin", current.lineJoin);
-      element.setAttributeNS(null, "stroke-width", pf(lineWidthScale * current.lineWidth) + "px");
-      element.setAttributeNS(null, "stroke-dasharray", dashArray.map(pf).join(" "));
-      element.setAttributeNS(null, "stroke-dashoffset", pf(lineWidthScale * current.dashPhase) + "px");
-    }
-
-    eoFill() {
-      if (this.current.element) {
-        this.current.element.setAttributeNS(null, "fill-rule", "evenodd");
+        this.fillStroke();
       }
-
-      this.fill();
-    }
-
-    fillStroke() {
-      this.stroke();
-      this.fill();
-    }
-
-    eoFillStroke() {
-      if (this.current.element) {
-        this.current.element.setAttributeNS(null, "fill-rule", "evenodd");
+    }, {
+      key: "closeStroke",
+      value: function closeStroke() {
+        this.closePath();
+        this.stroke();
       }
-
-      this.fillStroke();
-    }
-
-    closeStroke() {
-      this.closePath();
-      this.stroke();
-    }
-
-    closeFillStroke() {
-      this.closePath();
-      this.fillStroke();
-    }
-
-    closeEOFillStroke() {
-      this.closePath();
-      this.eoFillStroke();
-    }
-
-    paintSolidColorImageMask() {
-      const rect = this.svgFactory.createElement("svg:rect");
-      rect.setAttributeNS(null, "x", "0");
-      rect.setAttributeNS(null, "y", "0");
-      rect.setAttributeNS(null, "width", "1px");
-      rect.setAttributeNS(null, "height", "1px");
-      rect.setAttributeNS(null, "fill", this.current.fillColor);
-
-      this._ensureTransformGroup().appendChild(rect);
-    }
-
-    paintImageXObject(objId) {
-      const imgData = this.objs.get(objId);
-
-      if (!imgData) {
-        (0, _util.warn)(`Dependent image with object ID ${objId} is not ready yet`);
-        return;
+    }, {
+      key: "closeFillStroke",
+      value: function closeFillStroke() {
+        this.closePath();
+        this.fillStroke();
       }
-
-      this.paintInlineImageXObject(imgData);
-    }
-
-    paintInlineImageXObject(imgData, mask) {
-      const width = imgData.width;
-      const height = imgData.height;
-      const imgSrc = convertImgDataToPng(imgData, this.forceDataSchema, !!mask);
-      const cliprect = this.svgFactory.createElement("svg:rect");
-      cliprect.setAttributeNS(null, "x", "0");
-      cliprect.setAttributeNS(null, "y", "0");
-      cliprect.setAttributeNS(null, "width", pf(width));
-      cliprect.setAttributeNS(null, "height", pf(height));
-      this.current.element = cliprect;
-      this.clip("nonzero");
-      const imgEl = this.svgFactory.createElement("svg:image");
-      imgEl.setAttributeNS(XLINK_NS, "xlink:href", imgSrc);
-      imgEl.setAttributeNS(null, "x", "0");
-      imgEl.setAttributeNS(null, "y", pf(-height));
-      imgEl.setAttributeNS(null, "width", pf(width) + "px");
-      imgEl.setAttributeNS(null, "height", pf(height) + "px");
-      imgEl.setAttributeNS(null, "transform", `scale(${pf(1 / width)} ${pf(-1 / height)})`);
-
-      if (mask) {
-        mask.appendChild(imgEl);
-      } else {
-        this._ensureTransformGroup().appendChild(imgEl);
+    }, {
+      key: "closeEOFillStroke",
+      value: function closeEOFillStroke() {
+        this.closePath();
+        this.eoFillStroke();
       }
-    }
-
-    paintImageMaskXObject(imgData) {
-      const current = this.current;
-      const width = imgData.width;
-      const height = imgData.height;
-      const fillColor = current.fillColor;
-      current.maskId = `mask${maskCount++}`;
-      const mask = this.svgFactory.createElement("svg:mask");
-      mask.setAttributeNS(null, "id", current.maskId);
-      const rect = this.svgFactory.createElement("svg:rect");
-      rect.setAttributeNS(null, "x", "0");
-      rect.setAttributeNS(null, "y", "0");
-      rect.setAttributeNS(null, "width", pf(width));
-      rect.setAttributeNS(null, "height", pf(height));
-      rect.setAttributeNS(null, "fill", fillColor);
-      rect.setAttributeNS(null, "mask", `url(#${current.maskId})`);
-      this.defs.appendChild(mask);
+    }, {
+      key: "paintSolidColorImageMask",
+      value: function paintSolidColorImageMask() {
+        var rect = this.svgFactory.createElement("svg:rect");
+        rect.setAttributeNS(null, "x", "0");
+        rect.setAttributeNS(null, "y", "0");
+        rect.setAttributeNS(null, "width", "1px");
+        rect.setAttributeNS(null, "height", "1px");
+        rect.setAttributeNS(null, "fill", this.current.fillColor);
 
-      this._ensureTransformGroup().appendChild(rect);
+        this._ensureTransformGroup().appendChild(rect);
+      }
+    }, {
+      key: "paintImageXObject",
+      value: function paintImageXObject(objId) {
+        var imgData = this.objs.get(objId);
 
-      this.paintInlineImageXObject(imgData, mask);
-    }
+        if (!imgData) {
+          (0, _util.warn)("Dependent image with object ID ".concat(objId, " is not ready yet"));
+          return;
+        }
 
-    paintFormXObjectBegin(matrix, bbox) {
-      if (Array.isArray(matrix) && matrix.length === 6) {
-        this.transform(matrix[0], matrix[1], matrix[2], matrix[3], matrix[4], matrix[5]);
+        this.paintInlineImageXObject(imgData);
       }
-
-      if (bbox) {
-        const width = bbox[2] - bbox[0];
-        const height = bbox[3] - bbox[1];
-        const cliprect = this.svgFactory.createElement("svg:rect");
-        cliprect.setAttributeNS(null, "x", bbox[0]);
-        cliprect.setAttributeNS(null, "y", bbox[1]);
+    }, {
+      key: "paintInlineImageXObject",
+      value: function paintInlineImageXObject(imgData, mask) {
+        var width = imgData.width;
+        var height = imgData.height;
+        var imgSrc = convertImgDataToPng(imgData, this.forceDataSchema, !!mask);
+        var cliprect = this.svgFactory.createElement("svg:rect");
+        cliprect.setAttributeNS(null, "x", "0");
+        cliprect.setAttributeNS(null, "y", "0");
         cliprect.setAttributeNS(null, "width", pf(width));
         cliprect.setAttributeNS(null, "height", pf(height));
         this.current.element = cliprect;
         this.clip("nonzero");
-        this.endPath();
+        var imgEl = this.svgFactory.createElement("svg:image");
+        imgEl.setAttributeNS(XLINK_NS, "xlink:href", imgSrc);
+        imgEl.setAttributeNS(null, "x", "0");
+        imgEl.setAttributeNS(null, "y", pf(-height));
+        imgEl.setAttributeNS(null, "width", pf(width) + "px");
+        imgEl.setAttributeNS(null, "height", pf(height) + "px");
+        imgEl.setAttributeNS(null, "transform", "scale(".concat(pf(1 / width), " ").concat(pf(-1 / height), ")"));
+
+        if (mask) {
+          mask.appendChild(imgEl);
+        } else {
+          this._ensureTransformGroup().appendChild(imgEl);
+        }
       }
-    }
-
-    paintFormXObjectEnd() {}
-
-    _initialize(viewport) {
-      const svg = this.svgFactory.create(viewport.width, viewport.height);
-      const definitions = this.svgFactory.createElement("svg:defs");
-      svg.appendChild(definitions);
-      this.defs = definitions;
-      const rootGroup = this.svgFactory.createElement("svg:g");
-      rootGroup.setAttributeNS(null, "transform", pm(viewport.transform));
-      svg.appendChild(rootGroup);
-      this.svg = rootGroup;
-      return svg;
-    }
-
-    _ensureClipGroup() {
-      if (!this.current.clipGroup) {
-        const clipGroup = this.svgFactory.createElement("svg:g");
-        clipGroup.setAttributeNS(null, "clip-path", this.current.activeClipUrl);
-        this.svg.appendChild(clipGroup);
-        this.current.clipGroup = clipGroup;
+    }, {
+      key: "paintImageMaskXObject",
+      value: function paintImageMaskXObject(imgData) {
+        var current = this.current;
+        var width = imgData.width;
+        var height = imgData.height;
+        var fillColor = current.fillColor;
+        current.maskId = "mask".concat(maskCount++);
+        var mask = this.svgFactory.createElement("svg:mask");
+        mask.setAttributeNS(null, "id", current.maskId);
+        var rect = this.svgFactory.createElement("svg:rect");
+        rect.setAttributeNS(null, "x", "0");
+        rect.setAttributeNS(null, "y", "0");
+        rect.setAttributeNS(null, "width", pf(width));
+        rect.setAttributeNS(null, "height", pf(height));
+        rect.setAttributeNS(null, "fill", fillColor);
+        rect.setAttributeNS(null, "mask", "url(#".concat(current.maskId, ")"));
+        this.defs.appendChild(mask);
+
+        this._ensureTransformGroup().appendChild(rect);
+
+        this.paintInlineImageXObject(imgData, mask);
       }
+    }, {
+      key: "paintFormXObjectBegin",
+      value: function paintFormXObjectBegin(matrix, bbox) {
+        if (Array.isArray(matrix) && matrix.length === 6) {
+          this.transform(matrix[0], matrix[1], matrix[2], matrix[3], matrix[4], matrix[5]);
+        }
 
-      return this.current.clipGroup;
-    }
-
-    _ensureTransformGroup() {
-      if (!this.tgrp) {
-        this.tgrp = this.svgFactory.createElement("svg:g");
-        this.tgrp.setAttributeNS(null, "transform", pm(this.transformMatrix));
-
-        if (this.current.activeClipUrl) {
-          this._ensureClipGroup().appendChild(this.tgrp);
-        } else {
-          this.svg.appendChild(this.tgrp);
+        if (bbox) {
+          var width = bbox[2] - bbox[0];
+          var height = bbox[3] - bbox[1];
+          var cliprect = this.svgFactory.createElement("svg:rect");
+          cliprect.setAttributeNS(null, "x", bbox[0]);
+          cliprect.setAttributeNS(null, "y", bbox[1]);
+          cliprect.setAttributeNS(null, "width", pf(width));
+          cliprect.setAttributeNS(null, "height", pf(height));
+          this.current.element = cliprect;
+          this.clip("nonzero");
+          this.endPath();
         }
       }
+    }, {
+      key: "paintFormXObjectEnd",
+      value: function paintFormXObjectEnd() {}
+    }, {
+      key: "_initialize",
+      value: function _initialize(viewport) {
+        var svg = this.svgFactory.create(viewport.width, viewport.height);
+        var definitions = this.svgFactory.createElement("svg:defs");
+        svg.appendChild(definitions);
+        this.defs = definitions;
+        var rootGroup = this.svgFactory.createElement("svg:g");
+        rootGroup.setAttributeNS(null, "transform", pm(viewport.transform));
+        svg.appendChild(rootGroup);
+        this.svg = rootGroup;
+        return svg;
+      }
+    }, {
+      key: "_ensureClipGroup",
+      value: function _ensureClipGroup() {
+        if (!this.current.clipGroup) {
+          var clipGroup = this.svgFactory.createElement("svg:g");
+          clipGroup.setAttributeNS(null, "clip-path", this.current.activeClipUrl);
+          this.svg.appendChild(clipGroup);
+          this.current.clipGroup = clipGroup;
+        }
 
-      return this.tgrp;
-    }
+        return this.current.clipGroup;
+      }
+    }, {
+      key: "_ensureTransformGroup",
+      value: function _ensureTransformGroup() {
+        if (!this.tgrp) {
+          this.tgrp = this.svgFactory.createElement("svg:g");
+          this.tgrp.setAttributeNS(null, "transform", pm(this.transformMatrix));
+
+          if (this.current.activeClipUrl) {
+            this._ensureClipGroup().appendChild(this.tgrp);
+          } else {
+            this.svg.appendChild(this.tgrp);
+          }
+        }
 
-  };
+        return this.tgrp;
+      }
+    }]);
+
+    return SVGGraphics;
+  }();
 }
 
 /***/ }),
-/* 19 */
+/* 212 */
 /***/ (function(module, exports, __w_pdfjs_require__) {
 
 "use strict";
@@ -11901,31 +23668,61 @@ Object.defineProperty(exports, "__esModule", {
 });
 exports.PDFNodeStream = void 0;
 
-var _util = __w_pdfjs_require__(2);
+var _regenerator = _interopRequireDefault(__w_pdfjs_require__(2));
+
+var _util = __w_pdfjs_require__(5);
+
+var _network_utils = __w_pdfjs_require__(213);
+
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { "default": obj }; }
+
+function _typeof(obj) { "@babel/helpers - typeof"; 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 _inherits(subClass, superClass) { if (typeof superClass !== "function" && superClass !== null) { throw new TypeError("Super expression must either be null or a function"); } subClass.prototype = Object.create(superClass && superClass.prototype, { constructor: { value: subClass, writable: true, configurable: true } }); if (superClass) _setPrototypeOf(subClass, superClass); }
+
+function _setPrototypeOf(o, p) { _setPrototypeOf = Object.setPrototypeOf || function _setPrototypeOf(o, p) { o.__proto__ = p; return o; }; return _setPrototypeOf(o, p); }
+
+function _createSuper(Derived) { var hasNativeReflectConstruct = _isNativeReflectConstruct(); return function _createSuperInternal() { var Super = _getPrototypeOf(Derived), result; if (hasNativeReflectConstruct) { var NewTarget = _getPrototypeOf(this).constructor; result = Reflect.construct(Super, arguments, NewTarget); } else { result = Super.apply(this, arguments); } return _possibleConstructorReturn(this, result); }; }
+
+function _possibleConstructorReturn(self, call) { if (call && (_typeof(call) === "object" || typeof call === "function")) { return call; } return _assertThisInitialized(self); }
 
-var _network_utils = __w_pdfjs_require__(20);
+function _assertThisInitialized(self) { if (self === void 0) { throw new ReferenceError("this hasn't been initialised - super() hasn't been called"); } return self; }
+
+function _isNativeReflectConstruct() { if (typeof Reflect === "undefined" || !Reflect.construct) return false; if (Reflect.construct.sham) return false; if (typeof Proxy === "function") return true; try { Date.prototype.toString.call(Reflect.construct(Date, [], function () {})); return true; } catch (e) { return false; } }
+
+function _getPrototypeOf(o) { _getPrototypeOf = Object.setPrototypeOf ? Object.getPrototypeOf : function _getPrototypeOf(o) { return o.__proto__ || Object.getPrototypeOf(o); }; return _getPrototypeOf(o); }
+
+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; }
 
 ;
 
-const fs = require("fs");
+var fs = require("fs");
 
-const http = require("http");
+var http = require("http");
 
-const https = require("https");
+var https = require("https");
 
-const url = require("url");
+var url = require("url");
 
-const fileUriRegex = /^file:\/\/\/[a-zA-Z]:\//;
+var fileUriRegex = /^file:\/\/\/[a-zA-Z]:\//;
 
 function parseUrl(sourceUrl) {
-  const parsedUrl = url.parse(sourceUrl);
+  var parsedUrl = url.parse(sourceUrl);
 
   if (parsedUrl.protocol === "file:" || parsedUrl.host) {
     return parsedUrl;
   }
 
   if (/^[a-z]:[/\\]/i.test(sourceUrl)) {
-    return url.parse(`file:///${sourceUrl}`);
+    return url.parse("file:///".concat(sourceUrl));
   }
 
   if (!parsedUrl.host) {
@@ -11935,8 +23732,10 @@ function parseUrl(sourceUrl) {
   return parsedUrl;
 }
 
-class PDFNodeStream {
-  constructor(source) {
+var PDFNodeStream = /*#__PURE__*/function () {
+  function PDFNodeStream(source) {
+    _classCallCheck(this, PDFNodeStream);
+
     this.source = source;
     this.url = parseUrl(source.url);
     this.isHttp = this.url.protocol === "http:" || this.url.protocol === "https:";
@@ -11946,51 +23745,60 @@ class PDFNodeStream {
     this._rangeRequestReaders = [];
   }
 
-  get _progressiveDataLength() {
-    return this._fullRequestReader ? this._fullRequestReader._loaded : 0;
-  }
-
-  getFullReader() {
-    (0, _util.assert)(!this._fullRequestReader, "PDFNodeStream.getFullReader can only be called once.");
-    this._fullRequestReader = this.isFsUrl ? new PDFNodeStreamFsFullReader(this) : new PDFNodeStreamFullReader(this);
-    return this._fullRequestReader;
-  }
-
-  getRangeReader(start, end) {
-    if (end <= this._progressiveDataLength) {
-      return null;
+  _createClass(PDFNodeStream, [{
+    key: "getFullReader",
+    value: function getFullReader() {
+      (0, _util.assert)(!this._fullRequestReader, "PDFNodeStream.getFullReader can only be called once.");
+      this._fullRequestReader = this.isFsUrl ? new PDFNodeStreamFsFullReader(this) : new PDFNodeStreamFullReader(this);
+      return this._fullRequestReader;
     }
+  }, {
+    key: "getRangeReader",
+    value: function getRangeReader(start, end) {
+      if (end <= this._progressiveDataLength) {
+        return null;
+      }
 
-    const rangeReader = this.isFsUrl ? new PDFNodeStreamFsRangeReader(this, start, end) : new PDFNodeStreamRangeReader(this, start, end);
-
-    this._rangeRequestReaders.push(rangeReader);
+      var rangeReader = this.isFsUrl ? new PDFNodeStreamFsRangeReader(this, start, end) : new PDFNodeStreamRangeReader(this, start, end);
 
-    return rangeReader;
-  }
+      this._rangeRequestReaders.push(rangeReader);
 
-  cancelAllRequests(reason) {
-    if (this._fullRequestReader) {
-      this._fullRequestReader.cancel(reason);
+      return rangeReader;
     }
+  }, {
+    key: "cancelAllRequests",
+    value: function cancelAllRequests(reason) {
+      if (this._fullRequestReader) {
+        this._fullRequestReader.cancel(reason);
+      }
 
-    const readers = this._rangeRequestReaders.slice(0);
+      var readers = this._rangeRequestReaders.slice(0);
 
-    readers.forEach(function (reader) {
-      reader.cancel(reason);
-    });
-  }
+      readers.forEach(function (reader) {
+        reader.cancel(reason);
+      });
+    }
+  }, {
+    key: "_progressiveDataLength",
+    get: function get() {
+      return this._fullRequestReader ? this._fullRequestReader._loaded : 0;
+    }
+  }]);
 
-}
+  return PDFNodeStream;
+}();
 
 exports.PDFNodeStream = PDFNodeStream;
 
-class BaseFullReader {
-  constructor(stream) {
+var BaseFullReader = /*#__PURE__*/function () {
+  function BaseFullReader(stream) {
+    _classCallCheck(this, BaseFullReader);
+
     this._url = stream.url;
     this._done = false;
     this._storedError = null;
     this.onProgress = null;
-    const source = stream.source;
+    var source = stream.source;
     this._contentLength = source.length;
     this._loaded = 0;
     this._filename = null;
@@ -12008,107 +23816,157 @@ class BaseFullReader {
     this._headersCapability = (0, _util.createPromiseCapability)();
   }
 
-  get headersReady() {
-    return this._headersCapability.promise;
-  }
+  _createClass(BaseFullReader, [{
+    key: "read",
+    value: function () {
+      var _read = _asyncToGenerator( /*#__PURE__*/_regenerator["default"].mark(function _callee() {
+        var chunk, buffer;
+        return _regenerator["default"].wrap(function _callee$(_context) {
+          while (1) {
+            switch (_context.prev = _context.next) {
+              case 0:
+                _context.next = 2;
+                return this._readCapability.promise;
+
+              case 2:
+                if (!this._done) {
+                  _context.next = 4;
+                  break;
+                }
 
-  get filename() {
-    return this._filename;
-  }
+                return _context.abrupt("return", {
+                  value: undefined,
+                  done: true
+                });
 
-  get contentLength() {
-    return this._contentLength;
-  }
+              case 4:
+                if (!this._storedError) {
+                  _context.next = 6;
+                  break;
+                }
 
-  get isRangeSupported() {
-    return this._isRangeSupported;
-  }
+                throw this._storedError;
 
-  get isStreamingSupported() {
-    return this._isStreamingSupported;
-  }
+              case 6:
+                chunk = this._readableStream.read();
 
-  async read() {
-    await this._readCapability.promise;
+                if (!(chunk === null)) {
+                  _context.next = 10;
+                  break;
+                }
 
-    if (this._done) {
-      return {
-        value: undefined,
-        done: true
-      };
-    }
+                this._readCapability = (0, _util.createPromiseCapability)();
+                return _context.abrupt("return", this.read());
 
-    if (this._storedError) {
-      throw this._storedError;
-    }
+              case 10:
+                this._loaded += chunk.length;
 
-    const chunk = this._readableStream.read();
+                if (this.onProgress) {
+                  this.onProgress({
+                    loaded: this._loaded,
+                    total: this._contentLength
+                  });
+                }
 
-    if (chunk === null) {
-      this._readCapability = (0, _util.createPromiseCapability)();
-      return this.read();
-    }
+                buffer = new Uint8Array(chunk).buffer;
+                return _context.abrupt("return", {
+                  value: buffer,
+                  done: false
+                });
 
-    this._loaded += chunk.length;
+              case 14:
+              case "end":
+                return _context.stop();
+            }
+          }
+        }, _callee, this);
+      }));
 
-    if (this.onProgress) {
-      this.onProgress({
-        loaded: this._loaded,
-        total: this._contentLength
-      });
-    }
+      function read() {
+        return _read.apply(this, arguments);
+      }
 
-    const buffer = new Uint8Array(chunk).buffer;
-    return {
-      value: buffer,
-      done: false
-    };
-  }
+      return read;
+    }()
+  }, {
+    key: "cancel",
+    value: function cancel(reason) {
+      if (!this._readableStream) {
+        this._error(reason);
 
-  cancel(reason) {
-    if (!this._readableStream) {
-      this._error(reason);
+        return;
+      }
 
-      return;
+      this._readableStream.destroy(reason);
     }
+  }, {
+    key: "_error",
+    value: function _error(reason) {
+      this._storedError = reason;
 
-    this._readableStream.destroy(reason);
-  }
-
-  _error(reason) {
-    this._storedError = reason;
+      this._readCapability.resolve();
+    }
+  }, {
+    key: "_setReadableStream",
+    value: function _setReadableStream(readableStream) {
+      var _this = this;
 
-    this._readCapability.resolve();
-  }
+      this._readableStream = readableStream;
+      readableStream.on("readable", function () {
+        _this._readCapability.resolve();
+      });
+      readableStream.on("end", function () {
+        readableStream.destroy();
+        _this._done = true;
 
-  _setReadableStream(readableStream) {
-    this._readableStream = readableStream;
-    readableStream.on("readable", () => {
-      this._readCapability.resolve();
-    });
-    readableStream.on("end", () => {
-      readableStream.destroy();
-      this._done = true;
+        _this._readCapability.resolve();
+      });
+      readableStream.on("error", function (reason) {
+        _this._error(reason);
+      });
 
-      this._readCapability.resolve();
-    });
-    readableStream.on("error", reason => {
-      this._error(reason);
-    });
+      if (!this._isStreamingSupported && this._isRangeSupported) {
+        this._error(new _util.AbortException("streaming is disabled"));
+      }
 
-    if (!this._isStreamingSupported && this._isRangeSupported) {
-      this._error(new _util.AbortException("streaming is disabled"));
+      if (this._storedError) {
+        this._readableStream.destroy(this._storedError);
+      }
     }
-
-    if (this._storedError) {
-      this._readableStream.destroy(this._storedError);
+  }, {
+    key: "headersReady",
+    get: function get() {
+      return this._headersCapability.promise;
     }
-  }
+  }, {
+    key: "filename",
+    get: function get() {
+      return this._filename;
+    }
+  }, {
+    key: "contentLength",
+    get: function get() {
+      return this._contentLength;
+    }
+  }, {
+    key: "isRangeSupported",
+    get: function get() {
+      return this._isRangeSupported;
+    }
+  }, {
+    key: "isStreamingSupported",
+    get: function get() {
+      return this._isStreamingSupported;
+    }
+  }]);
 
-}
+  return BaseFullReader;
+}();
+
+var BaseRangeReader = /*#__PURE__*/function () {
+  function BaseRangeReader(stream) {
+    _classCallCheck(this, BaseRangeReader);
 
-class BaseRangeReader {
-  constructor(stream) {
     this._url = stream.url;
     this._done = false;
     this._storedError = null;
@@ -12116,87 +23974,131 @@ class BaseRangeReader {
     this._loaded = 0;
     this._readableStream = null;
     this._readCapability = (0, _util.createPromiseCapability)();
-    const source = stream.source;
+    var source = stream.source;
     this._isStreamingSupported = !source.disableStream;
   }
 
-  get isStreamingSupported() {
-    return this._isStreamingSupported;
-  }
+  _createClass(BaseRangeReader, [{
+    key: "read",
+    value: function () {
+      var _read2 = _asyncToGenerator( /*#__PURE__*/_regenerator["default"].mark(function _callee2() {
+        var chunk, buffer;
+        return _regenerator["default"].wrap(function _callee2$(_context2) {
+          while (1) {
+            switch (_context2.prev = _context2.next) {
+              case 0:
+                _context2.next = 2;
+                return this._readCapability.promise;
+
+              case 2:
+                if (!this._done) {
+                  _context2.next = 4;
+                  break;
+                }
 
-  async read() {
-    await this._readCapability.promise;
+                return _context2.abrupt("return", {
+                  value: undefined,
+                  done: true
+                });
 
-    if (this._done) {
-      return {
-        value: undefined,
-        done: true
-      };
-    }
+              case 4:
+                if (!this._storedError) {
+                  _context2.next = 6;
+                  break;
+                }
 
-    if (this._storedError) {
-      throw this._storedError;
-    }
+                throw this._storedError;
 
-    const chunk = this._readableStream.read();
+              case 6:
+                chunk = this._readableStream.read();
 
-    if (chunk === null) {
-      this._readCapability = (0, _util.createPromiseCapability)();
-      return this.read();
-    }
+                if (!(chunk === null)) {
+                  _context2.next = 10;
+                  break;
+                }
 
-    this._loaded += chunk.length;
+                this._readCapability = (0, _util.createPromiseCapability)();
+                return _context2.abrupt("return", this.read());
 
-    if (this.onProgress) {
-      this.onProgress({
-        loaded: this._loaded
-      });
-    }
+              case 10:
+                this._loaded += chunk.length;
 
-    const buffer = new Uint8Array(chunk).buffer;
-    return {
-      value: buffer,
-      done: false
-    };
-  }
+                if (this.onProgress) {
+                  this.onProgress({
+                    loaded: this._loaded
+                  });
+                }
 
-  cancel(reason) {
-    if (!this._readableStream) {
-      this._error(reason);
+                buffer = new Uint8Array(chunk).buffer;
+                return _context2.abrupt("return", {
+                  value: buffer,
+                  done: false
+                });
 
-      return;
-    }
+              case 14:
+              case "end":
+                return _context2.stop();
+            }
+          }
+        }, _callee2, this);
+      }));
 
-    this._readableStream.destroy(reason);
-  }
+      function read() {
+        return _read2.apply(this, arguments);
+      }
 
-  _error(reason) {
-    this._storedError = reason;
+      return read;
+    }()
+  }, {
+    key: "cancel",
+    value: function cancel(reason) {
+      if (!this._readableStream) {
+        this._error(reason);
 
-    this._readCapability.resolve();
-  }
+        return;
+      }
 
-  _setReadableStream(readableStream) {
-    this._readableStream = readableStream;
-    readableStream.on("readable", () => {
-      this._readCapability.resolve();
-    });
-    readableStream.on("end", () => {
-      readableStream.destroy();
-      this._done = true;
+      this._readableStream.destroy(reason);
+    }
+  }, {
+    key: "_error",
+    value: function _error(reason) {
+      this._storedError = reason;
 
       this._readCapability.resolve();
-    });
-    readableStream.on("error", reason => {
-      this._error(reason);
-    });
+    }
+  }, {
+    key: "_setReadableStream",
+    value: function _setReadableStream(readableStream) {
+      var _this2 = this;
 
-    if (this._storedError) {
-      this._readableStream.destroy(this._storedError);
+      this._readableStream = readableStream;
+      readableStream.on("readable", function () {
+        _this2._readCapability.resolve();
+      });
+      readableStream.on("end", function () {
+        readableStream.destroy();
+        _this2._done = true;
+
+        _this2._readCapability.resolve();
+      });
+      readableStream.on("error", function (reason) {
+        _this2._error(reason);
+      });
+
+      if (this._storedError) {
+        this._readableStream.destroy(this._storedError);
+      }
     }
-  }
+  }, {
+    key: "isStreamingSupported",
+    get: function get() {
+      return this._isStreamingSupported;
+    }
+  }]);
 
-}
+  return BaseRangeReader;
+}();
 
 function createRequestOptions(parsedUrl, headers) {
   return {
@@ -12206,160 +24108,203 @@ function createRequestOptions(parsedUrl, headers) {
     port: parsedUrl.port,
     path: parsedUrl.path,
     method: "GET",
-    headers
+    headers: headers
   };
 }
 
-class PDFNodeStreamFullReader extends BaseFullReader {
-  constructor(stream) {
-    super(stream);
+var PDFNodeStreamFullReader = /*#__PURE__*/function (_BaseFullReader) {
+  _inherits(PDFNodeStreamFullReader, _BaseFullReader);
+
+  var _super = _createSuper(PDFNodeStreamFullReader);
+
+  function PDFNodeStreamFullReader(stream) {
+    var _this3;
+
+    _classCallCheck(this, PDFNodeStreamFullReader);
+
+    _this3 = _super.call(this, stream);
 
-    const handleResponse = response => {
+    var handleResponse = function handleResponse(response) {
       if (response.statusCode === 404) {
-        const error = new _util.MissingPDFException(`Missing PDF "${this._url}".`);
-        this._storedError = error;
+        var error = new _util.MissingPDFException("Missing PDF \"".concat(_this3._url, "\"."));
+        _this3._storedError = error;
 
-        this._headersCapability.reject(error);
+        _this3._headersCapability.reject(error);
 
         return;
       }
 
-      this._headersCapability.resolve();
+      _this3._headersCapability.resolve();
 
-      this._setReadableStream(response);
+      _this3._setReadableStream(response);
 
-      const getResponseHeader = name => {
-        return this._readableStream.headers[name.toLowerCase()];
+      var getResponseHeader = function getResponseHeader(name) {
+        return _this3._readableStream.headers[name.toLowerCase()];
       };
 
-      const {
-        allowRangeRequests,
-        suggestedLength
-      } = (0, _network_utils.validateRangeRequestCapabilities)({
-        getResponseHeader,
+      var _validateRangeRequest = (0, _network_utils.validateRangeRequestCapabilities)({
+        getResponseHeader: getResponseHeader,
         isHttp: stream.isHttp,
-        rangeChunkSize: this._rangeChunkSize,
-        disableRange: this._disableRange
-      });
-      this._isRangeSupported = allowRangeRequests;
-      this._contentLength = suggestedLength || this._contentLength;
-      this._filename = (0, _network_utils.extractFilenameFromHeader)(getResponseHeader);
+        rangeChunkSize: _this3._rangeChunkSize,
+        disableRange: _this3._disableRange
+      }),
+          allowRangeRequests = _validateRangeRequest.allowRangeRequests,
+          suggestedLength = _validateRangeRequest.suggestedLength;
+
+      _this3._isRangeSupported = allowRangeRequests;
+      _this3._contentLength = suggestedLength || _this3._contentLength;
+      _this3._filename = (0, _network_utils.extractFilenameFromHeader)(getResponseHeader);
     };
 
-    this._request = null;
+    _this3._request = null;
 
-    if (this._url.protocol === "http:") {
-      this._request = http.request(createRequestOptions(this._url, stream.httpHeaders), handleResponse);
+    if (_this3._url.protocol === "http:") {
+      _this3._request = http.request(createRequestOptions(_this3._url, stream.httpHeaders), handleResponse);
     } else {
-      this._request = https.request(createRequestOptions(this._url, stream.httpHeaders), handleResponse);
+      _this3._request = https.request(createRequestOptions(_this3._url, stream.httpHeaders), handleResponse);
     }
 
-    this._request.on("error", reason => {
-      this._storedError = reason;
+    _this3._request.on("error", function (reason) {
+      _this3._storedError = reason;
 
-      this._headersCapability.reject(reason);
+      _this3._headersCapability.reject(reason);
     });
 
-    this._request.end();
+    _this3._request.end();
+
+    return _this3;
   }
 
-}
+  return PDFNodeStreamFullReader;
+}(BaseFullReader);
+
+var PDFNodeStreamRangeReader = /*#__PURE__*/function (_BaseRangeReader) {
+  _inherits(PDFNodeStreamRangeReader, _BaseRangeReader);
+
+  var _super2 = _createSuper(PDFNodeStreamRangeReader);
 
-class PDFNodeStreamRangeReader extends BaseRangeReader {
-  constructor(stream, start, end) {
-    super(stream);
-    this._httpHeaders = {};
+  function PDFNodeStreamRangeReader(stream, start, end) {
+    var _this4;
 
-    for (const property in stream.httpHeaders) {
-      const value = stream.httpHeaders[property];
+    _classCallCheck(this, PDFNodeStreamRangeReader);
+
+    _this4 = _super2.call(this, stream);
+    _this4._httpHeaders = {};
+
+    for (var property in stream.httpHeaders) {
+      var value = stream.httpHeaders[property];
 
       if (typeof value === "undefined") {
         continue;
       }
 
-      this._httpHeaders[property] = value;
+      _this4._httpHeaders[property] = value;
     }
 
-    this._httpHeaders.Range = `bytes=${start}-${end - 1}`;
+    _this4._httpHeaders.Range = "bytes=".concat(start, "-").concat(end - 1);
 
-    const handleResponse = response => {
+    var handleResponse = function handleResponse(response) {
       if (response.statusCode === 404) {
-        const error = new _util.MissingPDFException(`Missing PDF "${this._url}".`);
-        this._storedError = error;
+        var error = new _util.MissingPDFException("Missing PDF \"".concat(_this4._url, "\"."));
+        _this4._storedError = error;
         return;
       }
 
-      this._setReadableStream(response);
+      _this4._setReadableStream(response);
     };
 
-    this._request = null;
+    _this4._request = null;
 
-    if (this._url.protocol === "http:") {
-      this._request = http.request(createRequestOptions(this._url, this._httpHeaders), handleResponse);
+    if (_this4._url.protocol === "http:") {
+      _this4._request = http.request(createRequestOptions(_this4._url, _this4._httpHeaders), handleResponse);
     } else {
-      this._request = https.request(createRequestOptions(this._url, this._httpHeaders), handleResponse);
+      _this4._request = https.request(createRequestOptions(_this4._url, _this4._httpHeaders), handleResponse);
     }
 
-    this._request.on("error", reason => {
-      this._storedError = reason;
+    _this4._request.on("error", function (reason) {
+      _this4._storedError = reason;
     });
 
-    this._request.end();
+    _this4._request.end();
+
+    return _this4;
   }
 
-}
+  return PDFNodeStreamRangeReader;
+}(BaseRangeReader);
+
+var PDFNodeStreamFsFullReader = /*#__PURE__*/function (_BaseFullReader2) {
+  _inherits(PDFNodeStreamFsFullReader, _BaseFullReader2);
 
-class PDFNodeStreamFsFullReader extends BaseFullReader {
-  constructor(stream) {
-    super(stream);
-    let path = decodeURIComponent(this._url.path);
+  var _super3 = _createSuper(PDFNodeStreamFsFullReader);
 
-    if (fileUriRegex.test(this._url.href)) {
+  function PDFNodeStreamFsFullReader(stream) {
+    var _this5;
+
+    _classCallCheck(this, PDFNodeStreamFsFullReader);
+
+    _this5 = _super3.call(this, stream);
+    var path = decodeURIComponent(_this5._url.path);
+
+    if (fileUriRegex.test(_this5._url.href)) {
       path = path.replace(/^\//, "");
     }
 
-    fs.lstat(path, (error, stat) => {
+    fs.lstat(path, function (error, stat) {
       if (error) {
         if (error.code === "ENOENT") {
-          error = new _util.MissingPDFException(`Missing PDF "${path}".`);
+          error = new _util.MissingPDFException("Missing PDF \"".concat(path, "\"."));
         }
 
-        this._storedError = error;
+        _this5._storedError = error;
 
-        this._headersCapability.reject(error);
+        _this5._headersCapability.reject(error);
 
         return;
       }
 
-      this._contentLength = stat.size;
+      _this5._contentLength = stat.size;
 
-      this._setReadableStream(fs.createReadStream(path));
+      _this5._setReadableStream(fs.createReadStream(path));
 
-      this._headersCapability.resolve();
+      _this5._headersCapability.resolve();
     });
+    return _this5;
   }
 
-}
+  return PDFNodeStreamFsFullReader;
+}(BaseFullReader);
+
+var PDFNodeStreamFsRangeReader = /*#__PURE__*/function (_BaseRangeReader2) {
+  _inherits(PDFNodeStreamFsRangeReader, _BaseRangeReader2);
 
-class PDFNodeStreamFsRangeReader extends BaseRangeReader {
-  constructor(stream, start, end) {
-    super(stream);
-    let path = decodeURIComponent(this._url.path);
+  var _super4 = _createSuper(PDFNodeStreamFsRangeReader);
 
-    if (fileUriRegex.test(this._url.href)) {
+  function PDFNodeStreamFsRangeReader(stream, start, end) {
+    var _this6;
+
+    _classCallCheck(this, PDFNodeStreamFsRangeReader);
+
+    _this6 = _super4.call(this, stream);
+    var path = decodeURIComponent(_this6._url.path);
+
+    if (fileUriRegex.test(_this6._url.href)) {
       path = path.replace(/^\//, "");
     }
 
-    this._setReadableStream(fs.createReadStream(path, {
-      start,
+    _this6._setReadableStream(fs.createReadStream(path, {
+      start: start,
       end: end - 1
     }));
+
+    return _this6;
   }
 
-}
+  return PDFNodeStreamFsRangeReader;
+}(BaseRangeReader);
 
 /***/ }),
-/* 20 */
+/* 213 */
 /***/ (function(module, exports, __w_pdfjs_require__) {
 
 "use strict";
@@ -12373,22 +24318,21 @@ exports.extractFilenameFromHeader = extractFilenameFromHeader;
 exports.validateRangeRequestCapabilities = validateRangeRequestCapabilities;
 exports.validateResponseStatus = validateResponseStatus;
 
-var _util = __w_pdfjs_require__(2);
+var _util = __w_pdfjs_require__(5);
 
-var _content_disposition = __w_pdfjs_require__(21);
+var _content_disposition = __w_pdfjs_require__(214);
 
-function validateRangeRequestCapabilities({
-  getResponseHeader,
-  isHttp,
-  rangeChunkSize,
-  disableRange
-}) {
+function validateRangeRequestCapabilities(_ref) {
+  var getResponseHeader = _ref.getResponseHeader,
+      isHttp = _ref.isHttp,
+      rangeChunkSize = _ref.rangeChunkSize,
+      disableRange = _ref.disableRange;
   (0, _util.assert)(rangeChunkSize > 0, "Range chunk size must be larger than zero");
-  const returnValues = {
+  var returnValues = {
     allowRangeRequests: false,
     suggestedLength: undefined
   };
-  const length = parseInt(getResponseHeader("Content-Length"), 10);
+  var length = parseInt(getResponseHeader("Content-Length"), 10);
 
   if (!Number.isInteger(length)) {
     return returnValues;
@@ -12408,7 +24352,7 @@ function validateRangeRequestCapabilities({
     return returnValues;
   }
 
-  const contentEncoding = getResponseHeader("Content-Encoding") || "identity";
+  var contentEncoding = getResponseHeader("Content-Encoding") || "identity";
 
   if (contentEncoding !== "identity") {
     return returnValues;
@@ -12419,10 +24363,10 @@ function validateRangeRequestCapabilities({
 }
 
 function extractFilenameFromHeader(getResponseHeader) {
-  const contentDisposition = getResponseHeader("Content-Disposition");
+  var contentDisposition = getResponseHeader("Content-Disposition");
 
   if (contentDisposition) {
-    let filename = (0, _content_disposition.getFilenameFromContentDispositionHeader)(contentDisposition);
+    var filename = (0, _content_disposition.getFilenameFromContentDispositionHeader)(contentDisposition);
 
     if (filename.includes("%")) {
       try {
@@ -12451,7 +24395,7 @@ function validateResponseStatus(status) {
 }
 
 /***/ }),
-/* 21 */
+/* 214 */
 /***/ (function(module, exports, __w_pdfjs_require__) {
 
 "use strict";
@@ -12462,13 +24406,25 @@ Object.defineProperty(exports, "__esModule", {
 });
 exports.getFilenameFromContentDispositionHeader = getFilenameFromContentDispositionHeader;
 
+function _slicedToArray(arr, i) { return _arrayWithHoles(arr) || _iterableToArrayLimit(arr, i) || _unsupportedIterableToArray(arr, i) || _nonIterableRest(); }
+
+function _nonIterableRest() { throw new TypeError("Invalid attempt to destructure non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method."); }
+
+function _unsupportedIterableToArray(o, minLen) { if (!o) return; if (typeof o === "string") return _arrayLikeToArray(o, minLen); var n = Object.prototype.toString.call(o).slice(8, -1); if (n === "Object" && o.constructor) n = o.constructor.name; if (n === "Map" || n === "Set") return Array.from(o); if (n === "Arguments" || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(n)) return _arrayLikeToArray(o, minLen); }
+
+function _arrayLikeToArray(arr, len) { if (len == null || len > arr.length) len = arr.length; for (var i = 0, arr2 = new Array(len); i < len; i++) { arr2[i] = arr[i]; } return arr2; }
+
+function _iterableToArrayLimit(arr, i) { if (typeof Symbol === "undefined" || !(Symbol.iterator in Object(arr))) return; var _arr = []; var _n = true; var _d = false; var _e = undefined; try { for (var _i = arr[Symbol.iterator](), _s; !(_n = (_s = _i.next()).done); _n = true) { _arr.push(_s.value); if (i && _arr.length === i) break; } } catch (err) { _d = true; _e = err; } finally { try { if (!_n && _i["return"] != null) _i["return"](); } finally { if (_d) throw _e; } } return _arr; }
+
+function _arrayWithHoles(arr) { if (Array.isArray(arr)) return arr; }
+
 function getFilenameFromContentDispositionHeader(contentDisposition) {
-  let needsEncodingFixup = true;
-  let tmp = toParamRegExp("filename\\*", "i").exec(contentDisposition);
+  var needsEncodingFixup = true;
+  var tmp = toParamRegExp("filename\\*", "i").exec(contentDisposition);
 
   if (tmp) {
     tmp = tmp[1];
-    let filename = rfc2616unquote(tmp);
+    var filename = rfc2616unquote(tmp);
     filename = unescape(filename);
     filename = rfc5987decode(filename);
     filename = rfc2047decode(filename);
@@ -12478,17 +24434,20 @@ function getFilenameFromContentDispositionHeader(contentDisposition) {
   tmp = rfc2231getparam(contentDisposition);
 
   if (tmp) {
-    const filename = rfc2047decode(tmp);
-    return fixupEncoding(filename);
+    var _filename = rfc2047decode(tmp);
+
+    return fixupEncoding(_filename);
   }
 
   tmp = toParamRegExp("filename", "i").exec(contentDisposition);
 
   if (tmp) {
     tmp = tmp[1];
-    let filename = rfc2616unquote(tmp);
-    filename = rfc2047decode(filename);
-    return fixupEncoding(filename);
+
+    var _filename2 = rfc2616unquote(tmp);
+
+    _filename2 = rfc2047decode(_filename2);
+    return fixupEncoding(_filename2);
   }
 
   function toParamRegExp(attributePattern, flags) {
@@ -12502,10 +24461,10 @@ function getFilenameFromContentDispositionHeader(contentDisposition) {
       }
 
       try {
-        const decoder = new TextDecoder(encoding, {
+        var decoder = new TextDecoder(encoding, {
           fatal: true
         });
-        const bytes = Array.from(value, function (ch) {
+        var bytes = Array.from(value, function (ch) {
           return ch.charCodeAt(0) & 0xff;
         });
         value = decoder.decode(new Uint8Array(bytes));
@@ -12536,12 +24495,17 @@ function getFilenameFromContentDispositionHeader(contentDisposition) {
   }
 
   function rfc2231getparam(contentDispositionStr) {
-    const matches = [];
-    let match;
-    const iter = toParamRegExp("filename\\*((?!0\\d)\\d+)(\\*?)", "ig");
+    var matches = [];
+    var match;
+    var iter = toParamRegExp("filename\\*((?!0\\d)\\d+)(\\*?)", "ig");
 
     while ((match = iter.exec(contentDispositionStr)) !== null) {
-      let [, n, quot, part] = match;
+      var _match = match,
+          _match2 = _slicedToArray(_match, 4),
+          n = _match2[1],
+          quot = _match2[2],
+          part = _match2[3];
+
       n = parseInt(n, 10);
 
       if (n in matches) {
@@ -12555,25 +24519,28 @@ function getFilenameFromContentDispositionHeader(contentDisposition) {
       matches[n] = [quot, part];
     }
 
-    const parts = [];
+    var parts = [];
 
-    for (let n = 0; n < matches.length; ++n) {
-      if (!(n in matches)) {
+    for (var _n2 = 0; _n2 < matches.length; ++_n2) {
+      if (!(_n2 in matches)) {
         break;
       }
 
-      let [quot, part] = matches[n];
-      part = rfc2616unquote(part);
+      var _matches$_n = _slicedToArray(matches[_n2], 2),
+          _quot = _matches$_n[0],
+          _part = _matches$_n[1];
 
-      if (quot) {
-        part = unescape(part);
+      _part = rfc2616unquote(_part);
 
-        if (n === 0) {
-          part = rfc5987decode(part);
+      if (_quot) {
+        _part = unescape(_part);
+
+        if (_n2 === 0) {
+          _part = rfc5987decode(_part);
         }
       }
 
-      parts.push(part);
+      parts.push(_part);
     }
 
     return parts.join("");
@@ -12581,10 +24548,10 @@ function getFilenameFromContentDispositionHeader(contentDisposition) {
 
   function rfc2616unquote(value) {
     if (value.startsWith('"')) {
-      const parts = value.slice(1).split('\\"');
+      var parts = value.slice(1).split('\\"');
 
-      for (let i = 0; i < parts.length; ++i) {
-        const quotindex = parts[i].indexOf('"');
+      for (var i = 0; i < parts.length; ++i) {
+        var quotindex = parts[i].indexOf('"');
 
         if (quotindex !== -1) {
           parts[i] = parts[i].slice(0, quotindex);
@@ -12601,15 +24568,15 @@ function getFilenameFromContentDispositionHeader(contentDisposition) {
   }
 
   function rfc5987decode(extvalue) {
-    const encodingend = extvalue.indexOf("'");
+    var encodingend = extvalue.indexOf("'");
 
     if (encodingend === -1) {
       return extvalue;
     }
 
-    const encoding = extvalue.slice(0, encodingend);
-    const langvalue = extvalue.slice(encodingend + 1);
-    const value = langvalue.replace(/^[^']*'/, "");
+    var encoding = extvalue.slice(0, encodingend);
+    var langvalue = extvalue.slice(encodingend + 1);
+    var value = langvalue.replace(/^[^']*'/, "");
     return textdecode(encoding, value);
   }
 
@@ -12639,7 +24606,7 @@ function getFilenameFromContentDispositionHeader(contentDisposition) {
 }
 
 /***/ }),
-/* 22 */
+/* 215 */
 /***/ (function(module, exports, __w_pdfjs_require__) {
 
 "use strict";
@@ -12650,27 +24617,43 @@ Object.defineProperty(exports, "__esModule", {
 });
 exports.PDFNetworkStream = void 0;
 
-var _util = __w_pdfjs_require__(2);
+var _regenerator = _interopRequireDefault(__w_pdfjs_require__(2));
+
+var _util = __w_pdfjs_require__(5);
+
+var _network_utils = __w_pdfjs_require__(213);
+
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
 
-var _network_utils = __w_pdfjs_require__(20);
+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; }
 
 ;
-const OK_RESPONSE = 200;
-const PARTIAL_CONTENT_RESPONSE = 206;
+var OK_RESPONSE = 200;
+var PARTIAL_CONTENT_RESPONSE = 206;
 
 function getArrayBuffer(xhr) {
-  const data = xhr.response;
+  var data = xhr.response;
 
   if (typeof data !== "string") {
     return data;
   }
 
-  const array = (0, _util.stringToBytes)(data);
+  var array = (0, _util.stringToBytes)(data);
   return array.buffer;
 }
 
-class NetworkManager {
-  constructor(url, args) {
+var NetworkManager = /*#__PURE__*/function () {
+  function NetworkManager(url, args) {
+    _classCallCheck(this, NetworkManager);
+
     this.url = url;
     args = args || {};
     this.isHttp = /^https?:/i.test(url);
@@ -12685,173 +24668,188 @@ class NetworkManager {
     this.pendingRequests = Object.create(null);
   }
 
-  requestRange(begin, end, listeners) {
-    const args = {
-      begin,
-      end
-    };
+  _createClass(NetworkManager, [{
+    key: "requestRange",
+    value: function requestRange(begin, end, listeners) {
+      var args = {
+        begin: begin,
+        end: end
+      };
 
-    for (const prop in listeners) {
-      args[prop] = listeners[prop];
-    }
+      for (var prop in listeners) {
+        args[prop] = listeners[prop];
+      }
 
-    return this.request(args);
-  }
+      return this.request(args);
+    }
+  }, {
+    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;
 
-  requestFull(listeners) {
-    return this.request(listeners);
-  }
+      for (var property in this.httpHeaders) {
+        var value = this.httpHeaders[property];
 
-  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;
+        if (typeof value === "undefined") {
+          continue;
+        }
 
-    for (const property in this.httpHeaders) {
-      const value = this.httpHeaders[property];
+        xhr.setRequestHeader(property, value);
+      }
 
-      if (typeof value === "undefined") {
-        continue;
+      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;
       }
 
-      xhr.setRequestHeader(property, value);
-    }
+      xhr.responseType = "arraybuffer";
 
-    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;
+      if (args.onError) {
+        xhr.onerror = function (evt) {
+          args.onError(xhr.status);
+        };
+      }
+
+      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];
 
-    xhr.responseType = "arraybuffer";
+      if (!pendingRequest) {
+        return;
+      }
 
-    if (args.onError) {
-      xhr.onerror = function (evt) {
-        args.onError(xhr.status);
-      };
+      if (pendingRequest.onProgress) {
+        pendingRequest.onProgress(evt);
+      }
     }
+  }, {
+    key: "onStateChange",
+    value: function onStateChange(xhrId, evt) {
+      var pendingRequest = this.pendingRequests[xhrId];
 
-    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;
-  }
-
-  onProgress(xhrId, evt) {
-    const pendingRequest = this.pendingRequests[xhrId];
+      if (!pendingRequest) {
+        return;
+      }
 
-    if (!pendingRequest) {
-      return;
-    }
+      var xhr = pendingRequest.xhr;
 
-    if (pendingRequest.onProgress) {
-      pendingRequest.onProgress(evt);
-    }
-  }
+      if (xhr.readyState >= 2 && pendingRequest.onHeadersReceived) {
+        pendingRequest.onHeadersReceived();
+        delete pendingRequest.onHeadersReceived;
+      }
 
-  onStateChange(xhrId, evt) {
-    const pendingRequest = this.pendingRequests[xhrId];
+      if (xhr.readyState !== 4) {
+        return;
+      }
 
-    if (!pendingRequest) {
-      return;
-    }
+      if (!(xhrId in this.pendingRequests)) {
+        return;
+      }
 
-    const xhr = pendingRequest.xhr;
+      delete this.pendingRequests[xhrId];
 
-    if (xhr.readyState >= 2 && pendingRequest.onHeadersReceived) {
-      pendingRequest.onHeadersReceived();
-      delete pendingRequest.onHeadersReceived;
-    }
+      if (xhr.status === 0 && this.isHttp) {
+        if (pendingRequest.onError) {
+          pendingRequest.onError(xhr.status);
+        }
 
-    if (xhr.readyState !== 4) {
-      return;
-    }
+        return;
+      }
 
-    if (!(xhrId in this.pendingRequests)) {
-      return;
-    }
+      var xhrStatus = xhr.status || OK_RESPONSE;
+      var ok_response_on_range_request = xhrStatus === OK_RESPONSE && pendingRequest.expectedStatus === PARTIAL_CONTENT_RESPONSE;
 
-    delete this.pendingRequests[xhrId];
+      if (!ok_response_on_range_request && xhrStatus !== pendingRequest.expectedStatus) {
+        if (pendingRequest.onError) {
+          pendingRequest.onError(xhr.status);
+        }
 
-    if (xhr.status === 0 && this.isHttp) {
-      if (pendingRequest.onError) {
-        pendingRequest.onError(xhr.status);
+        return;
       }
 
-      return;
-    }
-
-    const xhrStatus = xhr.status || OK_RESPONSE;
-    const ok_response_on_range_request = xhrStatus === OK_RESPONSE && pendingRequest.expectedStatus === PARTIAL_CONTENT_RESPONSE;
+      var chunk = getArrayBuffer(xhr);
 
-    if (!ok_response_on_range_request && xhrStatus !== pendingRequest.expectedStatus) {
-      if (pendingRequest.onError) {
+      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) {
         pendingRequest.onError(xhr.status);
       }
-
-      return;
     }
+  }, {
+    key: "hasPendingRequests",
+    value: function hasPendingRequests() {
+      for (var xhrId in this.pendingRequests) {
+        return true;
+      }
 
-    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);
+      return false;
     }
-  }
-
-  hasPendingRequests() {
-    for (const xhrId in this.pendingRequests) {
-      return true;
+  }, {
+    key: "getRequestXhr",
+    value: function getRequestXhr(xhrId) {
+      return this.pendingRequests[xhrId].xhr;
     }
-
-    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);
+  }, {
+    key: "isPendingRequest",
+    value: function isPendingRequest(xhrId) {
+      return xhrId in this.pendingRequests;
     }
-  }
+  }, {
+    key: "abortAllRequests",
+    value: function abortAllRequests() {
+      for (var xhrId in this.pendingRequests) {
+        this.abortRequest(xhrId | 0);
+      }
+    }
+  }, {
+    key: "abortRequest",
+    value: function abortRequest(xhrId) {
+      var xhr = this.pendingRequests[xhrId].xhr;
+      delete this.pendingRequests[xhrId];
+      xhr.abort();
+    }
+  }]);
 
-  abortRequest(xhrId) {
-    const xhr = this.pendingRequests[xhrId].xhr;
-    delete this.pendingRequests[xhrId];
-    xhr.abort();
-  }
+  return NetworkManager;
+}();
 
-}
+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,
@@ -12862,49 +24860,58 @@ class PDFNetworkStream {
     this._rangeRequestReaders = [];
   }
 
-  _onRangeRequestReaderClosed(reader) {
-    const i = this._rangeRequestReaders.indexOf(reader);
+  _createClass(PDFNetworkStream, [{
+    key: "_onRangeRequestReaderClosed",
+    value: function _onRangeRequestReaderClosed(reader) {
+      var i = this._rangeRequestReaders.indexOf(reader);
 
-    if (i >= 0) {
-      this._rangeRequestReaders.splice(i, 1);
+      if (i >= 0) {
+        this._rangeRequestReaders.splice(i, 1);
+      }
     }
-  }
-
-  getFullReader() {
-    (0, _util.assert)(!this._fullRequestReader, "PDFNetworkStream.getFullReader can only be called once.");
-    this._fullRequestReader = new PDFNetworkStreamFullRequestReader(this._manager, this._source);
-    return this._fullRequestReader;
-  }
-
-  getRangeReader(begin, end) {
-    const reader = new PDFNetworkStreamRangeRequestReader(this._manager, begin, end);
-    reader.onClosed = this._onRangeRequestReaderClosed.bind(this);
-
-    this._rangeRequestReaders.push(reader);
+  }, {
+    key: "getFullReader",
+    value: function getFullReader() {
+      (0, _util.assert)(!this._fullRequestReader, "PDFNetworkStream.getFullReader can only be called once.");
+      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);
 
-    return reader;
-  }
+      this._rangeRequestReaders.push(reader);
 
-  cancelAllRequests(reason) {
-    if (this._fullRequestReader) {
-      this._fullRequestReader.cancel(reason);
+      return reader;
     }
+  }, {
+    key: "cancelAllRequests",
+    value: function cancelAllRequests(reason) {
+      if (this._fullRequestReader) {
+        this._fullRequestReader.cancel(reason);
+      }
 
-    const readers = this._rangeRequestReaders.slice(0);
+      var readers = this._rangeRequestReaders.slice(0);
 
-    readers.forEach(function (reader) {
-      reader.cancel(reason);
-    });
-  }
+      readers.forEach(function (reader) {
+        reader.cancel(reason);
+      });
+    }
+  }]);
 
-}
+  return PDFNetworkStream;
+}();
 
 exports.PDFNetworkStream = PDFNetworkStream;
 
-class PDFNetworkStreamFullRequestReader {
-  constructor(manager, source) {
+var PDFNetworkStreamFullRequestReader = /*#__PURE__*/function () {
+  function PDFNetworkStreamFullRequestReader(manager, source) {
+    _classCallCheck(this, PDFNetworkStreamFullRequestReader);
+
     this._manager = manager;
-    const args = {
+    var args = {
       onHeadersReceived: this._onHeadersReceived.bind(this),
       onDone: this._onDone.bind(this),
       onError: this._onError.bind(this),
@@ -12931,168 +24938,214 @@ class PDFNetworkStreamFullRequestReader {
     this.onProgress = null;
   }
 
-  _onHeadersReceived() {
-    const fullRequestXhrId = this._fullRequestId;
-
-    const fullRequestXhr = this._manager.getRequestXhr(fullRequestXhrId);
+  _createClass(PDFNetworkStreamFullRequestReader, [{
+    key: "_onHeadersReceived",
+    value: function _onHeadersReceived() {
+      var fullRequestXhrId = this._fullRequestId;
 
-    const getResponseHeader = name => {
-      return fullRequestXhr.getResponseHeader(name);
-    };
-
-    const {
-      allowRangeRequests,
-      suggestedLength
-    } = (0, _network_utils.validateRangeRequestCapabilities)({
-      getResponseHeader,
-      isHttp: this._manager.isHttp,
-      rangeChunkSize: this._rangeChunkSize,
-      disableRange: this._disableRange
-    });
+      var fullRequestXhr = this._manager.getRequestXhr(fullRequestXhrId);
 
-    if (allowRangeRequests) {
-      this._isRangeSupported = true;
-    }
-
-    this._contentLength = suggestedLength || this._contentLength;
-    this._filename = (0, _network_utils.extractFilenameFromHeader)(getResponseHeader);
+      var getResponseHeader = function getResponseHeader(name) {
+        return fullRequestXhr.getResponseHeader(name);
+      };
 
-    if (this._isRangeSupported) {
-      this._manager.abortRequest(fullRequestXhrId);
-    }
+      var _validateRangeRequest = (0, _network_utils.validateRangeRequestCapabilities)({
+        getResponseHeader: getResponseHeader,
+        isHttp: this._manager.isHttp,
+        rangeChunkSize: this._rangeChunkSize,
+        disableRange: this._disableRange
+      }),
+          allowRangeRequests = _validateRangeRequest.allowRangeRequests,
+          suggestedLength = _validateRangeRequest.suggestedLength;
 
-    this._headersReceivedCapability.resolve();
-  }
+      if (allowRangeRequests) {
+        this._isRangeSupported = true;
+      }
 
-  _onDone(args) {
-    if (args) {
-      if (this._requests.length > 0) {
-        const requestCapability = this._requests.shift();
+      this._contentLength = suggestedLength || this._contentLength;
+      this._filename = (0, _network_utils.extractFilenameFromHeader)(getResponseHeader);
 
-        requestCapability.resolve({
-          value: args.chunk,
-          done: false
-        });
-      } else {
-        this._cachedChunks.push(args.chunk);
+      if (this._isRangeSupported) {
+        this._manager.abortRequest(fullRequestXhrId);
       }
-    }
 
-    this._done = true;
-
-    if (this._cachedChunks.length > 0) {
-      return;
+      this._headersReceivedCapability.resolve();
     }
+  }, {
+    key: "_onDone",
+    value: function _onDone(args) {
+      if (args) {
+        if (this._requests.length > 0) {
+          var requestCapability = this._requests.shift();
 
-    this._requests.forEach(function (requestCapability) {
-      requestCapability.resolve({
-        value: undefined,
-        done: true
-      });
-    });
+          requestCapability.resolve({
+            value: args.chunk,
+            done: false
+          });
+        } else {
+          this._cachedChunks.push(args.chunk);
+        }
+      }
 
-    this._requests = [];
-  }
+      this._done = true;
 
-  _onError(status) {
-    const url = this._url;
-    const exception = (0, _network_utils.createResponseStatusError)(status, url);
-    this._storedError = exception;
+      if (this._cachedChunks.length > 0) {
+        return;
+      }
 
-    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 = [];
+    }
+  }, {
+    key: "_onError",
+    value: function _onError(status) {
+      var url = this._url;
+      var exception = (0, _network_utils.createResponseStatusError)(status, url);
+      this._storedError = exception;
 
-    this._requests = [];
-    this._cachedChunks = [];
-  }
+      this._headersReceivedCapability.reject(exception);
 
-  _onProgress(data) {
-    if (this.onProgress) {
-      this.onProgress({
-        loaded: data.loaded,
-        total: data.lengthComputable ? data.total : this._contentLength
+      this._requests.forEach(function (requestCapability) {
+        requestCapability.reject(exception);
       });
+
+      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;
+                }
 
-  get filename() {
-    return this._filename;
-  }
+                throw this._storedError;
 
-  get isRangeSupported() {
-    return this._isRangeSupported;
-  }
+              case 2:
+                if (!(this._cachedChunks.length > 0)) {
+                  _context.next = 5;
+                  break;
+                }
 
-  get isStreamingSupported() {
-    return this._isStreamingSupported;
-  }
+                chunk = this._cachedChunks.shift();
+                return _context.abrupt("return", {
+                  value: chunk,
+                  done: false
+                });
 
-  get contentLength() {
-    return this._contentLength;
-  }
+              case 5:
+                if (!this._done) {
+                  _context.next = 7;
+                  break;
+                }
 
-  get headersReady() {
-    return this._headersReceivedCapability.promise;
-  }
+                return _context.abrupt("return", {
+                  value: undefined,
+                  done: true
+                });
 
-  async read() {
-    if (this._storedError) {
-      throw this._storedError;
-    }
+              case 7:
+                requestCapability = (0, _util.createPromiseCapability)();
 
-    if (this._cachedChunks.length > 0) {
-      const chunk = this._cachedChunks.shift();
+                this._requests.push(requestCapability);
 
-      return {
-        value: chunk,
-        done: false
-      };
-    }
+                return _context.abrupt("return", requestCapability.promise);
 
-    if (this._done) {
-      return {
-        value: undefined,
-        done: true
-      };
-    }
-
-    const requestCapability = (0, _util.createPromiseCapability)();
-
-    this._requests.push(requestCapability);
+              case 10:
+              case "end":
+                return _context.stop();
+            }
+          }
+        }, _callee, this);
+      }));
 
-    return requestCapability.promise;
-  }
+      function read() {
+        return _read.apply(this, arguments);
+      }
 
-  cancel(reason) {
-    this._done = true;
+      return read;
+    }()
+  }, {
+    key: "cancel",
+    value: function cancel(reason) {
+      this._done = true;
 
-    this._headersReceivedCapability.reject(reason);
+      this._headersReceivedCapability.reject(reason);
 
-    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 = [];
+
+      if (this._manager.isPendingRequest(this._fullRequestId)) {
+        this._manager.abortRequest(this._fullRequestId);
+      }
 
-    if (this._manager.isPendingRequest(this._fullRequestId)) {
-      this._manager.abortRequest(this._fullRequestId);
+      this._fullRequestReader = null;
+    }
+  }, {
+    key: "filename",
+    get: function get() {
+      return this._filename;
+    }
+  }, {
+    key: "isRangeSupported",
+    get: function get() {
+      return this._isRangeSupported;
     }
+  }, {
+    key: "isStreamingSupported",
+    get: function get() {
+      return this._isStreamingSupported;
+    }
+  }, {
+    key: "contentLength",
+    get: function get() {
+      return this._contentLength;
+    }
+  }, {
+    key: "headersReady",
+    get: function get() {
+      return this._headersReceivedCapability.promise;
+    }
+  }]);
 
-    this._fullRequestReader = null;
-  }
+  return PDFNetworkStreamFullRequestReader;
+}();
 
-}
+var PDFNetworkStreamRangeRequestReader = /*#__PURE__*/function () {
+  function PDFNetworkStreamRangeRequestReader(manager, begin, end) {
+    _classCallCheck(this, PDFNetworkStreamRangeRequestReader);
 
-class PDFNetworkStreamRangeRequestReader {
-  constructor(manager, begin, end) {
     this._manager = manager;
-    const args = {
+    var args = {
       onDone: this._onDone.bind(this),
       onProgress: this._onProgress.bind(this)
     };
@@ -13104,99 +25157,136 @@ class PDFNetworkStreamRangeRequestReader {
     this.onClosed = null;
   }
 
-  _close() {
-    if (this.onClosed) {
-      this.onClosed(this);
+  _createClass(PDFNetworkStreamRangeRequestReader, [{
+    key: "_close",
+    value: function _close() {
+      if (this.onClosed) {
+        this.onClosed(this);
+      }
     }
-  }
+  }, {
+    key: "_onDone",
+    value: function _onDone(data) {
+      var chunk = data.chunk;
 
-  _onDone(data) {
-    const chunk = data.chunk;
-
-    if (this._requests.length > 0) {
-      const requestCapability = this._requests.shift();
+      if (this._requests.length > 0) {
+        var requestCapability = this._requests.shift();
 
-      requestCapability.resolve({
-        value: chunk,
-        done: false
-      });
-    } else {
-      this._queuedChunk = chunk;
-    }
+        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._close();
-  }
+      this._requests = [];
 
-  _onProgress(evt) {
-    if (!this.isStreamingSupported && this.onProgress) {
-      this.onProgress({
-        loaded: evt.loaded
-      });
+      this._close();
     }
-  }
+  }, {
+    key: "_onProgress",
+    value: function _onProgress(evt) {
+      if (!this.isStreamingSupported && this.onProgress) {
+        this.onProgress({
+          loaded: evt.loaded
+        });
+      }
+    }
+  }, {
+    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;
+                }
 
-  get isStreamingSupported() {
-    return false;
-  }
+                chunk = this._queuedChunk;
+                this._queuedChunk = null;
+                return _context2.abrupt("return", {
+                  value: chunk,
+                  done: false
+                });
+
+              case 4:
+                if (!this._done) {
+                  _context2.next = 6;
+                  break;
+                }
 
-  async read() {
-    if (this._queuedChunk !== null) {
-      const chunk = this._queuedChunk;
-      this._queuedChunk = null;
-      return {
-        value: chunk,
-        done: false
-      };
-    }
+                return _context2.abrupt("return", {
+                  value: undefined,
+                  done: true
+                });
 
-    if (this._done) {
-      return {
-        value: undefined,
-        done: true
-      };
-    }
+              case 6:
+                requestCapability = (0, _util.createPromiseCapability)();
 
-    const requestCapability = (0, _util.createPromiseCapability)();
+                this._requests.push(requestCapability);
 
-    this._requests.push(requestCapability);
+                return _context2.abrupt("return", requestCapability.promise);
 
-    return requestCapability.promise;
-  }
+              case 9:
+              case "end":
+                return _context2.stop();
+            }
+          }
+        }, _callee2, this);
+      }));
 
-  cancel(reason) {
-    this._done = true;
+      function read() {
+        return _read2.apply(this, arguments);
+      }
 
-    this._requests.forEach(function (requestCapability) {
-      requestCapability.resolve({
-        value: undefined,
-        done: true
+      return read;
+    }()
+  }, {
+    key: "cancel",
+    value: function cancel(reason) {
+      this._done = true;
+
+      this._requests.forEach(function (requestCapability) {
+        requestCapability.resolve({
+          value: undefined,
+          done: true
+        });
       });
-    });
 
-    this._requests = [];
+      this._requests = [];
 
-    if (this._manager.isPendingRequest(this._requestId)) {
-      this._manager.abortRequest(this._requestId);
-    }
+      if (this._manager.isPendingRequest(this._requestId)) {
+        this._manager.abortRequest(this._requestId);
+      }
 
-    this._close();
-  }
+      this._close();
+    }
+  }, {
+    key: "isStreamingSupported",
+    get: function get() {
+      return false;
+    }
+  }]);
 
-}
+  return PDFNetworkStreamRangeRequestReader;
+}();
 
 /***/ }),
-/* 23 */
+/* 216 */
 /***/ (function(module, exports, __w_pdfjs_require__) {
 
 "use strict";
@@ -13207,16 +25297,30 @@ Object.defineProperty(exports, "__esModule", {
 });
 exports.PDFFetchStream = void 0;
 
-var _util = __w_pdfjs_require__(2);
+var _regenerator = _interopRequireDefault(__w_pdfjs_require__(2));
+
+var _util = __w_pdfjs_require__(5);
+
+var _network_utils = __w_pdfjs_require__(213);
+
+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); }); }; }
 
-var _network_utils = __w_pdfjs_require__(20);
+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; }
 
 ;
 
 function createFetchOptions(headers, withCredentials, abortController) {
   return {
     method: "GET",
-    headers,
+    headers: headers,
     signal: abortController && abortController.signal,
     mode: "cors",
     credentials: withCredentials ? "include" : "same-origin",
@@ -13225,10 +25329,10 @@ function createFetchOptions(headers, withCredentials, abortController) {
 }
 
 function createHeaders(httpHeaders) {
-  const headers = new Headers();
+  var headers = new Headers();
 
-  for (const property in httpHeaders) {
-    const value = httpHeaders[property];
+  for (var property in httpHeaders) {
+    var value = httpHeaders[property];
 
     if (typeof value === "undefined") {
       continue;
@@ -13240,8 +25344,10 @@ function createHeaders(httpHeaders) {
   return headers;
 }
 
-class PDFFetchStream {
-  constructor(source) {
+var PDFFetchStream = /*#__PURE__*/function () {
+  function PDFFetchStream(source) {
+    _classCallCheck(this, PDFFetchStream);
+
     this.source = source;
     this.isHttp = /^https?:/i.test(source.url);
     this.httpHeaders = this.isHttp && source.httpHeaders || {};
@@ -13249,51 +25355,62 @@ class PDFFetchStream {
     this._rangeRequestReaders = [];
   }
 
-  get _progressiveDataLength() {
-    return this._fullRequestReader ? this._fullRequestReader._loaded : 0;
-  }
-
-  getFullReader() {
-    (0, _util.assert)(!this._fullRequestReader, "PDFFetchStream.getFullReader can only be called once.");
-    this._fullRequestReader = new PDFFetchStreamReader(this);
-    return this._fullRequestReader;
-  }
-
-  getRangeReader(begin, end) {
-    if (end <= this._progressiveDataLength) {
-      return null;
+  _createClass(PDFFetchStream, [{
+    key: "getFullReader",
+    value: function getFullReader() {
+      (0, _util.assert)(!this._fullRequestReader, "PDFFetchStream.getFullReader can only be called once.");
+      this._fullRequestReader = new PDFFetchStreamReader(this);
+      return this._fullRequestReader;
     }
+  }, {
+    key: "getRangeReader",
+    value: function getRangeReader(begin, end) {
+      if (end <= this._progressiveDataLength) {
+        return null;
+      }
 
-    const reader = new PDFFetchStreamRangeReader(this, begin, end);
-
-    this._rangeRequestReaders.push(reader);
+      var reader = new PDFFetchStreamRangeReader(this, begin, end);
 
-    return reader;
-  }
+      this._rangeRequestReaders.push(reader);
 
-  cancelAllRequests(reason) {
-    if (this._fullRequestReader) {
-      this._fullRequestReader.cancel(reason);
+      return reader;
     }
+  }, {
+    key: "cancelAllRequests",
+    value: function cancelAllRequests(reason) {
+      if (this._fullRequestReader) {
+        this._fullRequestReader.cancel(reason);
+      }
 
-    const readers = this._rangeRequestReaders.slice(0);
+      var readers = this._rangeRequestReaders.slice(0);
 
-    readers.forEach(function (reader) {
-      reader.cancel(reason);
-    });
-  }
+      readers.forEach(function (reader) {
+        reader.cancel(reason);
+      });
+    }
+  }, {
+    key: "_progressiveDataLength",
+    get: function get() {
+      return this._fullRequestReader ? this._fullRequestReader._loaded : 0;
+    }
+  }]);
 
-}
+  return PDFFetchStream;
+}();
 
 exports.PDFFetchStream = PDFFetchStream;
 
-class PDFFetchStreamReader {
-  constructor(stream) {
+var PDFFetchStreamReader = /*#__PURE__*/function () {
+  function PDFFetchStreamReader(stream) {
+    var _this = this;
+
+    _classCallCheck(this, PDFFetchStreamReader);
+
     this._stream = stream;
     this._reader = null;
     this._loaded = 0;
     this._filename = null;
-    const source = stream.source;
+    var source = stream.source;
     this._withCredentials = source.withCredentials || false;
     this._contentLength = source.length;
     this._headersCapability = (0, _util.createPromiseCapability)();
@@ -13311,108 +25428,153 @@ class PDFFetchStreamReader {
     this._isStreamingSupported = !source.disableStream;
     this._isRangeSupported = !source.disableRange;
     this._headers = createHeaders(this._stream.httpHeaders);
-    const url = source.url;
-    fetch(url, createFetchOptions(this._headers, this._withCredentials, this._abortController)).then(response => {
+    var url = source.url;
+    fetch(url, createFetchOptions(this._headers, this._withCredentials, this._abortController)).then(function (response) {
       if (!(0, _network_utils.validateResponseStatus)(response.status)) {
         throw (0, _network_utils.createResponseStatusError)(response.status, url);
       }
 
-      this._reader = response.body.getReader();
+      _this._reader = response.body.getReader();
 
-      this._headersCapability.resolve();
+      _this._headersCapability.resolve();
 
-      const getResponseHeader = name => {
+      var getResponseHeader = function getResponseHeader(name) {
         return response.headers.get(name);
       };
 
-      const {
-        allowRangeRequests,
-        suggestedLength
-      } = (0, _network_utils.validateRangeRequestCapabilities)({
-        getResponseHeader,
-        isHttp: this._stream.isHttp,
-        rangeChunkSize: this._rangeChunkSize,
-        disableRange: this._disableRange
-      });
-      this._isRangeSupported = allowRangeRequests;
-      this._contentLength = suggestedLength || this._contentLength;
-      this._filename = (0, _network_utils.extractFilenameFromHeader)(getResponseHeader);
+      var _validateRangeRequest = (0, _network_utils.validateRangeRequestCapabilities)({
+        getResponseHeader: getResponseHeader,
+        isHttp: _this._stream.isHttp,
+        rangeChunkSize: _this._rangeChunkSize,
+        disableRange: _this._disableRange
+      }),
+          allowRangeRequests = _validateRangeRequest.allowRangeRequests,
+          suggestedLength = _validateRangeRequest.suggestedLength;
 
-      if (!this._isStreamingSupported && this._isRangeSupported) {
-        this.cancel(new _util.AbortException("Streaming is disabled."));
+      _this._isRangeSupported = allowRangeRequests;
+      _this._contentLength = suggestedLength || _this._contentLength;
+      _this._filename = (0, _network_utils.extractFilenameFromHeader)(getResponseHeader);
+
+      if (!_this._isStreamingSupported && _this._isRangeSupported) {
+        _this.cancel(new _util.AbortException("Streaming is disabled."));
       }
-    }).catch(this._headersCapability.reject);
+    })["catch"](this._headersCapability.reject);
     this.onProgress = null;
   }
 
-  get headersReady() {
-    return this._headersCapability.promise;
-  }
+  _createClass(PDFFetchStreamReader, [{
+    key: "read",
+    value: function () {
+      var _read = _asyncToGenerator( /*#__PURE__*/_regenerator["default"].mark(function _callee() {
+        var _yield$this$_reader$r, value, done, buffer;
 
-  get filename() {
-    return this._filename;
-  }
+        return _regenerator["default"].wrap(function _callee$(_context) {
+          while (1) {
+            switch (_context.prev = _context.next) {
+              case 0:
+                _context.next = 2;
+                return this._headersCapability.promise;
 
-  get contentLength() {
-    return this._contentLength;
-  }
+              case 2:
+                _context.next = 4;
+                return this._reader.read();
 
-  get isRangeSupported() {
-    return this._isRangeSupported;
-  }
+              case 4:
+                _yield$this$_reader$r = _context.sent;
+                value = _yield$this$_reader$r.value;
+                done = _yield$this$_reader$r.done;
 
-  get isStreamingSupported() {
-    return this._isStreamingSupported;
-  }
+                if (!done) {
+                  _context.next = 9;
+                  break;
+                }
 
-  async read() {
-    await this._headersCapability.promise;
-    const {
-      value,
-      done
-    } = await this._reader.read();
+                return _context.abrupt("return", {
+                  value: value,
+                  done: done
+                });
 
-    if (done) {
-      return {
-        value,
-        done
-      };
-    }
+              case 9:
+                this._loaded += value.byteLength;
 
-    this._loaded += value.byteLength;
+                if (this.onProgress) {
+                  this.onProgress({
+                    loaded: this._loaded,
+                    total: this._contentLength
+                  });
+                }
 
-    if (this.onProgress) {
-      this.onProgress({
-        loaded: this._loaded,
-        total: this._contentLength
-      });
-    }
+                buffer = new Uint8Array(value).buffer;
+                return _context.abrupt("return", {
+                  value: buffer,
+                  done: false
+                });
 
-    const buffer = new Uint8Array(value).buffer;
-    return {
-      value: buffer,
-      done: false
-    };
-  }
+              case 13:
+              case "end":
+                return _context.stop();
+            }
+          }
+        }, _callee, this);
+      }));
 
-  cancel(reason) {
-    if (this._reader) {
-      this._reader.cancel(reason);
-    }
+      function read() {
+        return _read.apply(this, arguments);
+      }
 
-    if (this._abortController) {
-      this._abortController.abort();
+      return read;
+    }()
+  }, {
+    key: "cancel",
+    value: function cancel(reason) {
+      if (this._reader) {
+        this._reader.cancel(reason);
+      }
+
+      if (this._abortController) {
+        this._abortController.abort();
+      }
     }
-  }
+  }, {
+    key: "headersReady",
+    get: function get() {
+      return this._headersCapability.promise;
+    }
+  }, {
+    key: "filename",
+    get: function get() {
+      return this._filename;
+    }
+  }, {
+    key: "contentLength",
+    get: function get() {
+      return this._contentLength;
+    }
+  }, {
+    key: "isRangeSupported",
+    get: function get() {
+      return this._isRangeSupported;
+    }
+  }, {
+    key: "isStreamingSupported",
+    get: function get() {
+      return this._isStreamingSupported;
+    }
+  }]);
 
-}
+  return PDFFetchStreamReader;
+}();
+
+var PDFFetchStreamRangeReader = /*#__PURE__*/function () {
+  function PDFFetchStreamRangeReader(stream, begin, end) {
+    var _this2 = this;
+
+    _classCallCheck(this, PDFFetchStreamRangeReader);
 
-class PDFFetchStreamRangeReader {
-  constructor(stream, begin, end) {
     this._stream = stream;
     this._reader = null;
     this._loaded = 0;
-    const source = stream.source;
+    var source = stream.source;
     this._withCredentials = source.withCredentials || false;
     this._readCapability = (0, _util.createPromiseCapability)();
     this._isStreamingSupported = !source.disableStream;
@@ -13423,65 +25585,102 @@ class PDFFetchStreamRangeReader {
 
     this._headers = createHeaders(this._stream.httpHeaders);
 
-    this._headers.append("Range", `bytes=${begin}-${end - 1}`);
+    this._headers.append("Range", "bytes=".concat(begin, "-").concat(end - 1));
 
-    const url = source.url;
-    fetch(url, createFetchOptions(this._headers, this._withCredentials, this._abortController)).then(response => {
+    var url = source.url;
+    fetch(url, createFetchOptions(this._headers, this._withCredentials, this._abortController)).then(function (response) {
       if (!(0, _network_utils.validateResponseStatus)(response.status)) {
         throw (0, _network_utils.createResponseStatusError)(response.status, url);
       }
 
-      this._readCapability.resolve();
+      _this2._readCapability.resolve();
 
-      this._reader = response.body.getReader();
+      _this2._reader = response.body.getReader();
     });
     this.onProgress = null;
   }
 
-  get isStreamingSupported() {
-    return this._isStreamingSupported;
-  }
+  _createClass(PDFFetchStreamRangeReader, [{
+    key: "read",
+    value: function () {
+      var _read2 = _asyncToGenerator( /*#__PURE__*/_regenerator["default"].mark(function _callee2() {
+        var _yield$this$_reader$r2, value, done, buffer;
 
-  async read() {
-    await this._readCapability.promise;
-    const {
-      value,
-      done
-    } = await this._reader.read();
+        return _regenerator["default"].wrap(function _callee2$(_context2) {
+          while (1) {
+            switch (_context2.prev = _context2.next) {
+              case 0:
+                _context2.next = 2;
+                return this._readCapability.promise;
 
-    if (done) {
-      return {
-        value,
-        done
-      };
-    }
+              case 2:
+                _context2.next = 4;
+                return this._reader.read();
 
-    this._loaded += value.byteLength;
+              case 4:
+                _yield$this$_reader$r2 = _context2.sent;
+                value = _yield$this$_reader$r2.value;
+                done = _yield$this$_reader$r2.done;
 
-    if (this.onProgress) {
-      this.onProgress({
-        loaded: this._loaded
-      });
-    }
+                if (!done) {
+                  _context2.next = 9;
+                  break;
+                }
 
-    const buffer = new Uint8Array(value).buffer;
-    return {
-      value: buffer,
-      done: false
-    };
-  }
+                return _context2.abrupt("return", {
+                  value: value,
+                  done: done
+                });
 
-  cancel(reason) {
-    if (this._reader) {
-      this._reader.cancel(reason);
-    }
+              case 9:
+                this._loaded += value.byteLength;
+
+                if (this.onProgress) {
+                  this.onProgress({
+                    loaded: this._loaded
+                  });
+                }
+
+                buffer = new Uint8Array(value).buffer;
+                return _context2.abrupt("return", {
+                  value: buffer,
+                  done: false
+                });
+
+              case 13:
+              case "end":
+                return _context2.stop();
+            }
+          }
+        }, _callee2, this);
+      }));
 
-    if (this._abortController) {
-      this._abortController.abort();
+      function read() {
+        return _read2.apply(this, arguments);
+      }
+
+      return read;
+    }()
+  }, {
+    key: "cancel",
+    value: function cancel(reason) {
+      if (this._reader) {
+        this._reader.cancel(reason);
+      }
+
+      if (this._abortController) {
+        this._abortController.abort();
+      }
     }
-  }
+  }, {
+    key: "isStreamingSupported",
+    get: function get() {
+      return this._isStreamingSupported;
+    }
+  }]);
 
-}
+  return PDFFetchStreamRangeReader;
+}();
 
 /***/ })
 /******/ ]);