芝麻web文件管理V1.00

编辑当前文件:/home/mgatv524/novabrasil.mgaplay.com.br/web/media/pdf.worker.js

/**
 * @licstart The following is the entire license notice for the
 * Javascript code in this page
 *
 * Copyright 2019 Mozilla Foundation
 *
 * Licensed under the Apache License, Version 2.0 (the "License");
 * you may not use this file except in compliance with the License.
 * You may obtain a copy of the License at
 *
 *     http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 *
 * @licend The above is the entire license notice for the
 * Javascript code in this page
 */

(function webpackUniversalModuleDefinition(root, factory) {
	if(typeof exports === 'object' && typeof module === 'object')
		module.exports = factory();
	else if(typeof define === 'function' && define.amd)
		define("pdfjs-dist/build/pdf.worker", [], factory);
	else if(typeof exports === 'object')
		exports["pdfjs-dist/build/pdf.worker"] = factory();
	else
		root["pdfjs-dist/build/pdf.worker"] = root.pdfjsWorker = factory();
})(this, function() {
return /******/ (function(modules) { // webpackBootstrap
/******/ 	// The module cache
/******/ 	var installedModules = {};
/******/
/******/ 	// The require function
/******/ 	function __w_pdfjs_require__(moduleId) {
/******/
/******/ 		// Check if module is in cache
/******/ 		if(installedModules[moduleId]) {
/******/ 			return installedModules[moduleId].exports;
/******/ 		}
/******/ 		// Create a new module (and put it into the cache)
/******/ 		var module = installedModules[moduleId] = {
/******/ 			i: moduleId,
/******/ 			l: false,
/******/ 			exports: {}
/******/ 		};
/******/
/******/ 		// Execute the module function
/******/ 		modules[moduleId].call(module.exports, module, module.exports, __w_pdfjs_require__);
/******/
/******/ 		// Flag the module as loaded
/******/ 		module.l = true;
/******/
/******/ 		// Return the exports of the module
/******/ 		return module.exports;
/******/ 	}
/******/
/******/
/******/ 	// expose the modules object (__webpack_modules__)
/******/ 	__w_pdfjs_require__.m = modules;
/******/
/******/ 	// expose the module cache
/******/ 	__w_pdfjs_require__.c = installedModules;
/******/
/******/ 	// define getter function for harmony exports
/******/ 	__w_pdfjs_require__.d = function(exports, name, getter) {
/******/ 		if(!__w_pdfjs_require__.o(exports, name)) {
/******/ 			Object.defineProperty(exports, name, { enumerable: true, get: getter });
/******/ 		}
/******/ 	};
/******/
/******/ 	// define __esModule on exports
/******/ 	__w_pdfjs_require__.r = function(exports) {
/******/ 		if(typeof Symbol !== 'undefined' && Symbol.toStringTag) {
/******/ 			Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' });
/******/ 		}
/******/ 		Object.defineProperty(exports, '__esModule', { value: true });
/******/ 	};
/******/
/******/ 	// create a fake namespace object
/******/ 	// mode & 1: value is a module id, require it
/******/ 	// mode & 2: merge all properties of value into the ns
/******/ 	// mode & 4: return value when already ns object
/******/ 	// mode & 8|1: behave like require
/******/ 	__w_pdfjs_require__.t = function(value, mode) {
/******/ 		if(mode & 1) value = __w_pdfjs_require__(value);
/******/ 		if(mode & 8) return value;
/******/ 		if((mode & 4) && typeof value === 'object' && value && value.__esModule) return value;
/******/ 		var ns = Object.create(null);
/******/ 		__w_pdfjs_require__.r(ns);
/******/ 		Object.defineProperty(ns, 'default', { enumerable: true, value: value });
/******/ 		if(mode & 2 && typeof value != 'string') for(var key in value) __w_pdfjs_require__.d(ns, key, function(key) { return value[key]; }.bind(null, key));
/******/ 		return ns;
/******/ 	};
/******/
/******/ 	// getDefaultExport function for compatibility with non-harmony modules
/******/ 	__w_pdfjs_require__.n = function(module) {
/******/ 		var getter = module && module.__esModule ?
/******/ 			function getDefault() { return module['default']; } :
/******/ 			function getModuleExports() { return module; };
/******/ 		__w_pdfjs_require__.d(getter, 'a', getter);
/******/ 		return getter;
/******/ 	};
/******/
/******/ 	// Object.prototype.hasOwnProperty.call
/******/ 	__w_pdfjs_require__.o = function(object, property) { return Object.prototype.hasOwnProperty.call(object, property); };
/******/
/******/ 	// __webpack_public_path__
/******/ 	__w_pdfjs_require__.p = "";
/******/
/******/
/******/ 	// Load entry module and return exports
/******/ 	return __w_pdfjs_require__(__w_pdfjs_require__.s = 0);
/******/ })
/************************************************************************/
/******/ ([
/* 0 */
/***/ (function(module, exports, __w_pdfjs_require__) {

"use strict";

var pdfjsVersion = '2.3.200';
var pdfjsBuild = '4ae3f9fc';

var pdfjsCoreWorker = __w_pdfjs_require__(1);

exports.WorkerMessageHandler = pdfjsCoreWorker.WorkerMessageHandler;

/***/ }),
/* 1 */
/***/ (function(module, exports, __w_pdfjs_require__) {

"use strict";

Object.defineProperty(exports, "__esModule", {
  value: true
});
exports.WorkerMessageHandler = exports.WorkerTask = void 0;

var _regenerator = _interopRequireDefault(__w_pdfjs_require__(2));

var _util = __w_pdfjs_require__(5);

var _primitives = __w_pdfjs_require__(183);

var _pdf_manager = __w_pdfjs_require__(184);

var _is_node = _interopRequireDefault(__w_pdfjs_require__(8));

var _message_handler = __w_pdfjs_require__(223);

var _worker_stream = __w_pdfjs_require__(224);

var _core_utils = __w_pdfjs_require__(186);

function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { "default": obj }; }

function _slicedToArray(arr, i) { return _arrayWithHoles(arr) || _iterableToArrayLimit(arr, i) || _nonIterableRest(); }

function _nonIterableRest() { throw new TypeError("Invalid attempt to destructure non-iterable instance"); }

function _arrayWithHoles(arr) { if (Array.isArray(arr)) return arr; }

var WorkerTask = function WorkerTaskClosure() {
  function WorkerTask(name) {
    this.name = name;
    this.terminated = false;
    this._capability = (0, _util.createPromiseCapability)();
  }

WorkerTask.prototype = {
    get finished() {
      return this._capability.promise;
    },

finish: function finish() {
      this._capability.resolve();
    },
    terminate: function terminate() {
      this.terminated = true;
    },
    ensureNotTerminated: function ensureNotTerminated() {
      if (this.terminated) {
        throw new Error('Worker task was terminated');
      }
    }
  };
  return WorkerTask;
}();

exports.WorkerTask = WorkerTask;
var WorkerMessageHandler = {
  setup: function setup(handler, port) {
    var testMessageProcessed = false;
    handler.on('test', function wphSetupTest(data) {
      if (testMessageProcessed) {
        return;
      }

testMessageProcessed = true;

if (!(data instanceof Uint8Array)) {
        handler.send('test', null);
        return;
      }

if (apiVersion !== workerVersion) {
      throw new Error("The API version \"".concat(apiVersion, "\" does not match ") + "the Worker version \"".concat(workerVersion, "\"."));
    }

var docId = docParams.docId;
    var docBaseUrl = docParams.docBaseUrl;
    var workerHandlerName = docParams.docId + '_worker';
    var handler = new _message_handler.MessageHandler(workerHandlerName, docId, port);
    handler.postMessageTransfers = docParams.postMessageTransfers;

function ensureNotTerminated() {
      if (terminated) {
        throw new Error('Worker was terminated');
      }
    }

function startWorkerTask(task) {
      WorkerTasks.push(task);
    }

function finishWorkerTask(task) {
      task.finish();
      var i = WorkerTasks.indexOf(task);
      WorkerTasks.splice(i, 1);
    }

function loadDocument(_x) {
      return _loadDocument.apply(this, arguments);
    }

function _loadDocument() {
      _loadDocument = _asyncToGenerator(
      /*#__PURE__*/
      _regenerator["default"].mark(function _callee(recoveryMode) {
        var _ref4, _ref5, numPages, fingerprint;

return _regenerator["default"].wrap(function _callee$(_context) {
          while (1) {
            switch (_context.prev = _context.next) {
              case 0:
                _context.next = 2;
                return pdfManager.ensureDoc('checkHeader');

case 2:
                _context.next = 4;
                return pdfManager.ensureDoc('parseStartXRef');

case 4:
                _context.next = 6;
                return pdfManager.ensureDoc('parse', [recoveryMode]);

case 6:
                if (recoveryMode) {
                  _context.next = 9;
                  break;
                }

_context.next = 9;
                return pdfManager.ensureDoc('checkFirstPage');

case 9:
                _context.next = 11;
                return Promise.all([pdfManager.ensureDoc('numPages'), pdfManager.ensureDoc('fingerprint')]);

case 11:
                _ref4 = _context.sent;
                _ref5 = _slicedToArray(_ref4, 2);
                numPages = _ref5[0];
                fingerprint = _ref5[1];
                return _context.abrupt("return", {
                  numPages: numPages,
                  fingerprint: fingerprint
                });

case 16:
              case "end":
                return _context.stop();
            }
          }
        }, _callee);
      }));
      return _loadDocument.apply(this, arguments);
    }

function getPdfManager(data, evaluatorOptions) {
      var pdfManagerCapability = (0, _util.createPromiseCapability)();
      var pdfManager;
      var source = data.source;

if (source.data) {
        try {
          pdfManager = new _pdf_manager.LocalPdfManager(docId, source.data, source.password, evaluatorOptions, docBaseUrl);
          pdfManagerCapability.resolve(pdfManager);
        } catch (ex) {
          pdfManagerCapability.reject(ex);
        }

return pdfManagerCapability.promise;
      }

var pdfStream,
          cachedChunks = [];

try {
        pdfStream = new _worker_stream.PDFWorkerStream(handler);
      } catch (ex) {
        pdfManagerCapability.reject(ex);
        return pdfManagerCapability.promise;
      }

var fullRequest = pdfStream.getFullReader();
      fullRequest.headersReady.then(function () {
        if (!fullRequest.isRangeSupported) {
          return;
        }

var disableAutoFetch = source.disableAutoFetch || fullRequest.isStreamingSupported;
        pdfManager = new _pdf_manager.NetworkPdfManager(docId, pdfStream, {
          msgHandler: handler,
          password: source.password,
          length: fullRequest.contentLength,
          disableAutoFetch: disableAutoFetch,
          rangeChunkSize: source.rangeChunkSize
        }, evaluatorOptions, docBaseUrl);

for (var i = 0; i < cachedChunks.length; i++) {
          pdfManager.sendProgressiveData(cachedChunks[i]);
        }

cachedChunks = [];
        pdfManagerCapability.resolve(pdfManager);
        cancelXHRs = null;
      })["catch"](function (reason) {
        pdfManagerCapability.reject(reason);
        cancelXHRs = null;
      });
      var loaded = 0;

var flushChunks = function flushChunks() {
        var pdfFile = (0, _util.arraysToBytes)(cachedChunks);

if (source.length && pdfFile.length !== source.length) {
          (0, _util.warn)('reported HTTP length is different from actual');
        }

try {
          pdfManager = new _pdf_manager.LocalPdfManager(docId, pdfFile, source.password, evaluatorOptions, docBaseUrl);
          pdfManagerCapability.resolve(pdfManager);
        } catch (ex) {
          pdfManagerCapability.reject(ex);
        }

cachedChunks = [];
      };

var readPromise = new Promise(function (resolve, reject) {
        var readChunk = function readChunk(chunk) {
          try {
            ensureNotTerminated();

if (chunk.done) {
              if (!pdfManager) {
                flushChunks();
              }

cancelXHRs = null;
              return;
            }

var data = chunk.value;
            loaded += (0, _util.arrayByteLength)(data);

if (!fullRequest.isStreamingSupported) {
              handler.send('DocProgress', {
                loaded: loaded,
                total: Math.max(loaded, fullRequest.contentLength || 0)
              });
            }

if (pdfManager) {
              pdfManager.sendProgressiveData(data);
            } else {
              cachedChunks.push(data);
            }

fullRequest.read().then(readChunk, reject);
          } catch (e) {
            reject(e);
          }
        };

fullRequest.read().then(readChunk, reject);
      });
      readPromise["catch"](function (e) {
        pdfManagerCapability.reject(e);
        cancelXHRs = null;
      });

cancelXHRs = function cancelXHRs(reason) {
        pdfStream.cancelAllRequests(reason);
      };

return pdfManagerCapability.promise;
    }

function setupDoc(data) {
      function onSuccess(doc) {
        ensureNotTerminated();
        handler.send('GetDoc', {
          pdfInfo: doc
        });
      }

function onFailure(e) {
        ensureNotTerminated();

if (e instanceof _util.PasswordException) {
          var task = new WorkerTask('PasswordException: response ' + e.code);
          startWorkerTask(task);
          handler.sendWithPromise('PasswordRequest', e).then(function (data) {
            finishWorkerTask(task);
            pdfManager.updatePassword(data.password);
            pdfManagerReady();
          })["catch"](function (boundException) {
            finishWorkerTask(task);
            handler.send('PasswordException', boundException);
          }.bind(null, e));
        } else if (e instanceof _util.InvalidPDFException) {
          handler.send('InvalidPDF', e);
        } else if (e instanceof _util.MissingPDFException) {
          handler.send('MissingPDF', e);
        } else if (e instanceof _util.UnexpectedResponseException) {
          handler.send('UnexpectedResponse', e);
        } else {
          handler.send('UnknownError', new _util.UnknownErrorException(e.message, e.toString()));
        }
      }

function pdfManagerReady() {
        ensureNotTerminated();
        loadDocument(false).then(onSuccess, function loadFailure(ex) {
          ensureNotTerminated();

if (!(ex instanceof _core_utils.XRefParseException)) {
            onFailure(ex);
            return;
          }

pdfManager.requestLoadedStream();
          pdfManager.onLoadedStream().then(function () {
            ensureNotTerminated();
            loadDocument(true).then(onSuccess, onFailure);
          });
        }, onFailure);
      }

ensureNotTerminated();
      var evaluatorOptions = {
        forceDataSchema: data.disableCreateObjectURL,
        maxImageSize: data.maxImageSize,
        disableFontFace: data.disableFontFace,
        nativeImageDecoderSupport: data.nativeImageDecoderSupport,
        ignoreErrors: data.ignoreErrors,
        isEvalSupported: data.isEvalSupported
      };
      getPdfManager(data, evaluatorOptions).then(function (newPdfManager) {
        if (terminated) {
          newPdfManager.terminate(new _util.AbortException('Worker was terminated.'));
          throw new Error('Worker was terminated');
        }

pdfManager = newPdfManager;
        pdfManager.onLoadedStream().then(function (stream) {
          handler.send('DataLoaded', {
            length: stream.bytes.byteLength
          });
        });
      }).then(pdfManagerReady, onFailure);
    }

handler.on('GetPage', function wphSetupGetPage(data) {
      return pdfManager.getPage(data.pageIndex).then(function (page) {
        return Promise.all([pdfManager.ensure(page, 'rotate'), pdfManager.ensure(page, 'ref'), pdfManager.ensure(page, 'userUnit'), pdfManager.ensure(page, 'view')]).then(function (_ref) {
          var _ref2 = _slicedToArray(_ref, 4),
              rotate = _ref2[0],
              ref = _ref2[1],
              userUnit = _ref2[2],
              view = _ref2[3];

return {
            rotate: rotate,
            ref: ref,
            userUnit: userUnit,
            view: view
          };
        });
      });
    });
    handler.on('GetPageIndex', function wphSetupGetPageIndex(data) {
      var ref = _primitives.Ref.get(data.ref.num, data.ref.gen);

if (start) {
            (0, _util.info)("page=".concat(pageIndex + 1, " - getOperatorList: time=") + "".concat(Date.now() - start, "ms, len=").concat(operatorListInfo.length));
          }

sink.close();
        }, function (reason) {
          finishWorkerTask(task);

if (task.terminated) {
            return;
          }

handler.send('UnsupportedFeature', {
            featureId: _util.UNSUPPORTED_FEATURES.unknown
          });
          sink.error(reason);
        });
      });
    }, this);
    handler.on('GetTextContent', function wphExtractText(data, sink) {
      var pageIndex = data.pageIndex;

sink.onPull = function (desiredSize) {};

sink.onCancel = function (reason) {};

pdfManager.getPage(pageIndex).then(function (page) {
        var task = new WorkerTask('GetTextContent: page ' + pageIndex);
        startWorkerTask(task);
        var start = verbosity >= _util.VerbosityLevel.INFOS ? Date.now() : 0;
        page.extractTextContent({
          handler: handler,
          task: task,
          sink: sink,
          normalizeWhitespace: data.normalizeWhitespace,
          combineTextItems: data.combineTextItems
        }).then(function () {
          finishWorkerTask(task);

if (start) {
            (0, _util.info)("page=".concat(pageIndex + 1, " - getTextContent: time=") + "".concat(Date.now() - start, "ms"));
          }

sink.close();
        }, function (reason) {
          finishWorkerTask(task);

if (task.terminated) {
            return;
          }

sink.error(reason);
        });
      });
    });
    handler.on('FontFallback', function (data) {
      return pdfManager.fontFallback(data.id, handler);
    });
    handler.on('Cleanup', function wphCleanup(data) {
      return pdfManager.cleanup();
    });
    handler.on('Terminate', function wphTerminate(data) {
      terminated = true;

if (pdfManager) {
        pdfManager.terminate(new _util.AbortException('Worker was terminated.'));
        pdfManager = null;
      }

if (cancelXHRs) {
        cancelXHRs(new _util.AbortException('Worker was terminated.'));
      }

(0, _primitives.clearPrimitiveCaches)();
      var waitOn = [];
      WorkerTasks.forEach(function (task) {
        waitOn.push(task.finished);
        task.terminate();
      });
      return Promise.all(waitOn).then(function () {
        handler.destroy();
        handler = null;
      });
    });
    handler.on('Ready', function wphReady(data) {
      setupDoc(docParams);
      docParams = null;
    });
    return workerHandlerName;
  },
  initializeFromPort: function initializeFromPort(port) {
    var handler = new _message_handler.MessageHandler('worker', 'main', port);
    WorkerMessageHandler.setup(handler, port);
    handler.send('ready', null);
  }
};
exports.WorkerMessageHandler = WorkerMessageHandler;

function isMessagePort(maybePort) {
  return typeof maybePort.postMessage === 'function' && 'onmessage' in maybePort;
}

if (typeof window === 'undefined' && !(0, _is_node["default"])() && typeof self !== 'undefined' && isMessagePort(self)) {
  WorkerMessageHandler.initializeFromPort(self);
}

/***/ }),
/* 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) {

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";

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 (!(toStringTagSymbol in genFun)) {
        genFun[toStringTagSymbol] = "GeneratorFunction";
      }
    }

genFun.prototype = Object.create(Gp);
    return genFun;
  };

exports.awrap = function (arg) {
    return {
      __await: arg
    };
  };

function AsyncIterator(generator) {
    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 Promise.resolve(value.__await).then(function (value) {
            invoke("next", value, resolve, reject);
          }, function (err) {
            invoke("throw", err, resolve, reject);
          });
        }

return Promise.resolve(value).then(function (unwrapped) {
          result.value = unwrapped;
          resolve(result);
        }, function (error) {
          return invoke("throw", error, resolve, reject);
        });
      }
    }

var previousPromise;

function enqueue(method, arg) {
      function callInvokeWithMethodAndArg() {
        return new Promise(function (resolve, reject) {
          invoke(method, arg, resolve, reject);
        });
      }

return previousPromise = previousPromise ? previousPromise.then(callInvokeWithMethodAndArg, callInvokeWithMethodAndArg) : callInvokeWithMethodAndArg();
    }

this._invoke = enqueue;
  }

defineIteratorMethods(AsyncIterator.prototype);

AsyncIterator.prototype[asyncIteratorSymbol] = function () {
    return this;
  };

exports.AsyncIterator = AsyncIterator;

exports.async = function (innerFn, outerFn, self, tryLocsList) {
    var iter = new AsyncIterator(wrap(innerFn, outerFn, self, tryLocsList));
    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)))

/***/ }),
/* 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;
};

/***/ }),
/* 5 */
/***/ (function(module, exports, __w_pdfjs_require__) {

"use strict";

Object.defineProperty(exports, "__esModule", {
  value: true
});
exports.arrayByteLength = arrayByteLength;
exports.arraysToBytes = arraysToBytes;
exports.assert = assert;
exports.bytesToString = bytesToString;
exports.createPromiseCapability = createPromiseCapability;
exports.getVerbosityLevel = getVerbosityLevel;
exports.info = info;
exports.isArrayBuffer = isArrayBuffer;
exports.isArrayEqual = isArrayEqual;
exports.isBool = isBool;
exports.isEmptyObj = isEmptyObj;
exports.isNum = isNum;
exports.isString = isString;
exports.isSpace = isSpace;
exports.isSameOrigin = isSameOrigin;
exports.createValidAbsoluteUrl = createValidAbsoluteUrl;
exports.isLittleEndian = isLittleEndian;
exports.isEvalSupported = isEvalSupported;
exports.log2 = log2;
exports.readInt8 = readInt8;
exports.readUint16 = readUint16;
exports.readUint32 = readUint32;
exports.removeNullCharacters = removeNullCharacters;
exports.setVerbosityLevel = setVerbosityLevel;
exports.shadow = shadow;
exports.string32 = string32;
exports.stringToBytes = stringToBytes;
exports.stringToPDFString = stringToPDFString;
exports.stringToUTF8String = stringToUTF8String;
exports.utf8StringToString = utf8StringToString;
exports.warn = warn;
exports.unreachable = unreachable;
Object.defineProperty(exports, "ReadableStream", {
  enumerable: true,
  get: function () {
    return _streams_polyfill.ReadableStream;
  }
});
exports.createObjectURL = exports.FormatError = exports.Util = exports.UnknownErrorException = exports.UnexpectedResponseException = exports.TextRenderingMode = exports.StreamType = exports.PermissionFlag = exports.PasswordResponses = exports.PasswordException = exports.NativeImageDecoding = 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__(6);

var _streams_polyfill = __w_pdfjs_require__(181);

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 _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }

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 _getPrototypeOf(o) { _getPrototypeOf = Object.setPrototypeOf ? Object.getPrototypeOf : function _getPrototypeOf(o) { return o.__proto__ || Object.getPrototypeOf(o); }; return _getPrototypeOf(o); }

function _setPrototypeOf(o, p) { _setPrototypeOf = Object.setPrototypeOf || function _setPrototypeOf(o, p) { o.__proto__ = p; return o; }; return _setPrototypeOf(o, p); }

function setVerbosityLevel(level) {
  if (Number.isInteger(level)) {
    verbosity = level;
  }
}

function getVerbosityLevel() {
  return verbosity;
}

function info(msg) {
  if (verbosity >= VerbosityLevel.INFOS) {
    console.log("Info: ".concat(msg));
  }
}

function warn(msg) {
  if (verbosity >= VerbosityLevel.WARNINGS) {
    console.log("Warning: ".concat(msg));
  }
}

function unreachable(msg) {
  throw new Error(msg);
}

function assert(cond, msg) {
  if (!cond) {
    unreachable(msg);
  }
}

function isSameOrigin(baseUrl, otherUrl) {
  var base;

try {
    base = new URL(baseUrl);

if (!base.origin || base.origin === 'null') {
      return false;
    }
  } catch (e) {
    return false;
  }

var other = new URL(otherUrl, base);
  return base.origin === other.origin;
}

function _isValidProtocol(url) {
  if (!url) {
    return false;
  }

switch (url.protocol) {
    case 'http:':
    case 'https:':
    case 'ftp:':
    case 'mailto:':
    case 'tel:':
      return true;

default:
      return false;
  }
}

function createValidAbsoluteUrl(url, baseUrl) {
  if (!url) {
    return null;
  }

try {
    var absoluteUrl = baseUrl ? new URL(url, baseUrl) : new URL(url);

if (_isValidProtocol(absoluteUrl)) {
      return absoluteUrl;
    }
  } catch (ex) {}

return null;
}

function shadow(obj, prop, value) {
  Object.defineProperty(obj, prop, {
    value: value,
    enumerable: true,
    configurable: true,
    writable: false
  });
  return value;
}

var BaseException = function BaseExceptionClosure() {
  function BaseException(message) {
    if (this.constructor === BaseException) {
      unreachable('Cannot initialize BaseException.');
    }

this.message = message;
    this.name = this.constructor.name;
  }

BaseException.prototype = new Error();
  BaseException.constructor = BaseException;
  return BaseException;
}();

exports.BaseException = BaseException;

var PasswordException =
/*#__PURE__*/
function (_BaseException) {
  _inherits(PasswordException, _BaseException);

function PasswordException(msg, code) {
    var _this;

_classCallCheck(this, PasswordException);

_this = _possibleConstructorReturn(this, _getPrototypeOf(PasswordException).call(this, msg));
    _this.code = code;
    return _this;
  }

return PasswordException;
}(BaseException);

exports.PasswordException = PasswordException;

var UnknownErrorException =
/*#__PURE__*/
function (_BaseException2) {
  _inherits(UnknownErrorException, _BaseException2);

function UnknownErrorException(msg, details) {
    var _this2;

_classCallCheck(this, UnknownErrorException);

_this2 = _possibleConstructorReturn(this, _getPrototypeOf(UnknownErrorException).call(this, msg));
    _this2.details = details;
    return _this2;
  }

return UnknownErrorException;
}(BaseException);

exports.UnknownErrorException = UnknownErrorException;

var InvalidPDFException =
/*#__PURE__*/
function (_BaseException3) {
  _inherits(InvalidPDFException, _BaseException3);

function InvalidPDFException() {
    _classCallCheck(this, InvalidPDFException);

return _possibleConstructorReturn(this, _getPrototypeOf(InvalidPDFException).apply(this, arguments));
  }

return InvalidPDFException;
}(BaseException);

exports.InvalidPDFException = InvalidPDFException;

var MissingPDFException =
/*#__PURE__*/
function (_BaseException4) {
  _inherits(MissingPDFException, _BaseException4);

function MissingPDFException() {
    _classCallCheck(this, MissingPDFException);

return _possibleConstructorReturn(this, _getPrototypeOf(MissingPDFException).apply(this, arguments));
  }

return MissingPDFException;
}(BaseException);

exports.MissingPDFException = MissingPDFException;

var UnexpectedResponseException =
/*#__PURE__*/
function (_BaseException5) {
  _inherits(UnexpectedResponseException, _BaseException5);

function UnexpectedResponseException(msg, status) {
    var _this3;

_classCallCheck(this, UnexpectedResponseException);

_this3 = _possibleConstructorReturn(this, _getPrototypeOf(UnexpectedResponseException).call(this, msg));
    _this3.status = status;
    return _this3;
  }

return UnexpectedResponseException;
}(BaseException);

exports.UnexpectedResponseException = UnexpectedResponseException;

var FormatError =
/*#__PURE__*/
function (_BaseException6) {
  _inherits(FormatError, _BaseException6);

function FormatError() {
    _classCallCheck(this, FormatError);

return _possibleConstructorReturn(this, _getPrototypeOf(FormatError).apply(this, arguments));
  }

return FormatError;
}(BaseException);

exports.FormatError = FormatError;

var AbortException =
/*#__PURE__*/
function (_BaseException7) {
  _inherits(AbortException, _BaseException7);

function AbortException() {
    _classCallCheck(this, AbortException);

return _possibleConstructorReturn(this, _getPrototypeOf(AbortException).apply(this, arguments));
  }

return AbortException;
}(BaseException);

exports.AbortException = AbortException;
var NullCharactersRegExp = /\x00/g;

function removeNullCharacters(str) {
  if (typeof str !== 'string') {
    warn('The argument for removeNullCharacters must be a string.');
    return str;
  }

return str.replace(NullCharactersRegExp, '');
}

function bytesToString(bytes) {
  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);
  }

var strBuf = [];

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));
  }

return strBuf.join('');
}

function stringToBytes(str) {
  assert(typeof str === 'string', 'Invalid argument for stringToBytes');
  var length = str.length;
  var bytes = new Uint8Array(length);

for (var i = 0; i < length; ++i) {
    bytes[i] = str.charCodeAt(i) & 0xFF;
  }

return bytes;
}

function arrayByteLength(arr) {
  if (arr.length !== undefined) {
    return arr.length;
  }

assert(arr.byteLength !== undefined);
  return arr.byteLength;
}

function arraysToBytes(arr) {
  var length = arr.length;

if (length === 1 && arr[0] instanceof Uint8Array) {
    return arr[0];
  }

var resultLength = 0;

for (var i = 0; i < length; i++) {
    resultLength += arrayByteLength(arr[i]);
  }

var pos = 0;
  var data = new Uint8Array(resultLength);

for (var _i = 0; _i < length; _i++) {
    var item = arr[_i];

if (!(item instanceof Uint8Array)) {
      if (typeof item === 'string') {
        item = stringToBytes(item);
      } else {
        item = new Uint8Array(item);
      }
    }

var itemLength = item.byteLength;
    data.set(item, pos);
    pos += itemLength;
  }

return data;
}

function string32(value) {
  return String.fromCharCode(value >> 24 & 0xff, value >> 16 & 0xff, value >> 8 & 0xff, value & 0xff);
}

function log2(x) {
  if (x <= 0) {
    return 0;
  }

return Math.ceil(Math.log2(x));
}

function readInt8(data, start) {
  return data[start] << 24 >> 24;
}

function readUint16(data, offset) {
  return data[offset] << 8 | data[offset + 1];
}

function readUint32(data, offset) {
  return (data[offset] << 24 | data[offset + 1] << 16 | data[offset + 2] << 8 | data[offset + 3]) >>> 0;
}

function isLittleEndian() {
  var buffer8 = new Uint8Array(4);
  buffer8[0] = 1;
  var view32 = new Uint32Array(buffer8.buffer, 0, 1);
  return view32[0] === 1;
}

function isEvalSupported() {
  try {
    new Function('');
    return true;
  } catch (e) {
    return false;
  }
}

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 (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 Util;
}();

exports.Util = Util;
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) {
  var length = str.length,
      strBuf = [];

if (str[0] === '\xFE' && str[1] === '\xFF') {
    for (var i = 2; i < length; i += 2) {
      strBuf.push(String.fromCharCode(str.charCodeAt(i) << 8 | str.charCodeAt(i + 1)));
    }
  } else {
    for (var _i2 = 0; _i2 < length; ++_i2) {
      var code = PDFStringTranslateTable[str.charCodeAt(_i2)];
      strBuf.push(code ? String.fromCharCode(code) : str.charAt(_i2));
    }
  }

return strBuf.join('');
}

function stringToUTF8String(str) {
  return decodeURIComponent(escape(str));
}

function utf8StringToString(str) {
  return unescape(encodeURIComponent(str));
}

function isEmptyObj(obj) {
  for (var key in obj) {
    return false;
  }

return true;
}

function isBool(v) {
  return typeof v === 'boolean';
}

function isNum(v) {
  return typeof v === 'number';
}

function isString(v) {
  return typeof v === 'string';
}

function isArrayBuffer(v) {
  return _typeof(v) === 'object' && v !== null && v.byteLength !== undefined;
}

function isArrayEqual(arr1, arr2) {
  if (arr1.length !== arr2.length) {
    return false;
  }

return arr1.every(function (element, index) {
    return element === arr2[index];
  });
}

function isSpace(ch) {
  return ch === 0x20 || ch === 0x09 || ch === 0x0D || ch === 0x0A;
}

capability.reject = function (reason) {
      isSettled = true;
      reject(reason);
    };
  });
  return capability;
}

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) {
      var blob = new Blob([data], {
        type: contentType
      });
      return URL.createObjectURL(blob);
    }

var buffer = "data:".concat(contentType, ";base64,");

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];
    }

return buffer;
  };
}();

exports.createObjectURL = createObjectURL;

/***/ }),
/* 6 */
/***/ (function(module, exports, __w_pdfjs_require__) {

"use strict";

var globalScope = __w_pdfjs_require__(7);

if (!globalScope._pdfjsCompatibilityChecked) {
  globalScope._pdfjsCompatibilityChecked = true;

var isNodeJS = __w_pdfjs_require__(8);

var hasDOM = (typeof window === "undefined" ? "undefined" : _typeof(window)) === 'object' && (typeof document === "undefined" ? "undefined" : _typeof(document)) === 'object';

(function checkNodeBtoa() {
    if (globalScope.btoa || !isNodeJS()) {
      return;
    }

globalScope.btoa = function (chars) {
      return Buffer.from(chars, 'binary').toString('base64');
    };
  })();

(function checkNodeAtob() {
    if (globalScope.atob || !isNodeJS()) {
      return;
    }

globalScope.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 || 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 || 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 checkStringStartsWith() {
    if (String.prototype.startsWith) {
      return;
    }

__w_pdfjs_require__(9);
  })();

(function checkStringEndsWith() {
    if (String.prototype.endsWith) {
      return;
    }

__w_pdfjs_require__(61);
  })();

(function checkStringIncludes() {
    if (String.prototype.includes) {
      return;
    }

__w_pdfjs_require__(63);
  })();

(function checkArrayIncludes() {
    if (Array.prototype.includes) {
      return;
    }

__w_pdfjs_require__(65);
  })();

(function checkArrayFrom() {
    if (Array.from) {
      return;
    }

__w_pdfjs_require__(72);
  })();

(function checkObjectAssign() {
    if (Object.assign) {
      return;
    }

__w_pdfjs_require__(93);
  })();

(function checkMathLog2() {
    if (Math.log2) {
      return;
    }

Math.log2 = __w_pdfjs_require__(96);
  })();

(function checkNumberIsNaN() {
    if (Number.isNaN) {
      return;
    }

Number.isNaN = __w_pdfjs_require__(98);
  })();

(function checkNumberIsInteger() {
    if (Number.isInteger) {
      return;
    }

Number.isInteger = __w_pdfjs_require__(100);
  })();

(function checkPromise() {
    if (globalScope.Promise && globalScope.Promise.prototype && globalScope.Promise.prototype["finally"]) {
      return;
    }

globalScope.Promise = __w_pdfjs_require__(103);
  })();

(function checkURL() {
    globalScope.URL = __w_pdfjs_require__(125);
  })();

(function checkWeakMap() {
    if (globalScope.WeakMap) {
      return;
    }

globalScope.WeakMap = __w_pdfjs_require__(132);
  })();

(function checkWeakSet() {
    if (globalScope.WeakSet) {
      return;
    }

globalScope.WeakSet = __w_pdfjs_require__(142);
  })();

(function checkStringCodePointAt() {
    if (String.prototype.codePointAt) {
      return;
    }

__w_pdfjs_require__(144);
  })();

(function checkStringFromCodePoint() {
    if (String.fromCodePoint) {
      return;
    }

String.fromCodePoint = __w_pdfjs_require__(146);
  })();

(function checkSymbol() {
    if (globalScope.Symbol) {
      return;
    }

__w_pdfjs_require__(148);
  })();

(function checkStringPadStart() {
    if (String.prototype.padStart) {
      return;
    }

__w_pdfjs_require__(171);
  })();

(function checkStringPadEnd() {
    if (String.prototype.padEnd) {
      return;
    }

__w_pdfjs_require__(176);
  })();

(function checkObjectValues() {
    if (Object.values) {
      return;
    }

Object.values = __w_pdfjs_require__(178);
  })();
}

/***/ }),
/* 7 */
/***/ (function(module, exports, __w_pdfjs_require__) {

"use strict";

module.exports = typeof window !== 'undefined' && window.Math === Math ? window : typeof global !== 'undefined' && global.Math === Math ? global : typeof self !== 'undefined' && self.Math === Math ? self : {};

/***/ }),
/* 8 */
/***/ (function(module, exports, __w_pdfjs_require__) {

"use strict";

module.exports = function isNodeJS() {
  return (typeof process === "undefined" ? "undefined" : _typeof(process)) === 'object' && process + '' === '[object process]' && !process.versions['nw'] && !process.versions['electron'];
};

/***/ }),
/* 9 */
/***/ (function(module, exports, __w_pdfjs_require__) {

__w_pdfjs_require__(10);
var entryUnbind = __w_pdfjs_require__(58);
module.exports = entryUnbind('String', 'startsWith');

/***/ }),
/* 10 */
/***/ (function(module, exports, __w_pdfjs_require__) {

"use strict";

/***/ }),
/* 11 */
/***/ (function(module, exports, __w_pdfjs_require__) {

/***/ }),
/* 12 */
/***/ (function(module, exports) {

var O = 'object';
var check = function (it) {
 return it && it.Math == Math && it;
};
module.exports = check(typeof globalThis == O && globalThis) || check(typeof window == O && window) || check(typeof self == O && self) || check(typeof global == O && global) || Function('return this')();

/***/ }),
/* 13 */
/***/ (function(module, exports, __w_pdfjs_require__) {

/***/ }),
/* 14 */
/***/ (function(module, exports, __w_pdfjs_require__) {

var fails = __w_pdfjs_require__(15);
module.exports = !fails(function () {
 return Object.defineProperty({}, 'a', {
  get: function () {
   return 7;
  }
 }).a != 7;
});

/***/ }),
/* 15 */
/***/ (function(module, exports) {

module.exports = function (exec) {
 try {
  return !!exec();
 } catch (error) {
  return true;
 }
};

/***/ }),
/* 16 */
/***/ (function(module, exports, __w_pdfjs_require__) {

"use strict";

/***/ }),
/* 17 */
/***/ (function(module, exports) {

module.exports = function (bitmap, value) {
 return {
  enumerable: !(bitmap & 1),
  configurable: !(bitmap & 2),
  writable: !(bitmap & 4),
  value: value
 };
};

/***/ }),
/* 18 */
/***/ (function(module, exports, __w_pdfjs_require__) {

var IndexedObject = __w_pdfjs_require__(19);
var requireObjectCoercible = __w_pdfjs_require__(21);
module.exports = function (it) {
 return IndexedObject(requireObjectCoercible(it));
};

/***/ }),
/* 19 */
/***/ (function(module, exports, __w_pdfjs_require__) {

var fails = __w_pdfjs_require__(15);
var classof = __w_pdfjs_require__(20);
var split = ''.split;
module.exports = fails(function () {
 return !Object('z').propertyIsEnumerable(0);
}) ? function (it) {
 return classof(it) == 'String' ? split.call(it, '') : Object(it);
} : Object;

/***/ }),
/* 20 */
/***/ (function(module, exports) {

var toString = {}.toString;
module.exports = function (it) {
 return toString.call(it).slice(8, -1);
};

/***/ }),
/* 21 */
/***/ (function(module, exports) {

module.exports = function (it) {
 if (it == undefined)
  throw TypeError("Can't call method on " + it);
 return it;
};

/***/ }),
/* 22 */
/***/ (function(module, exports, __w_pdfjs_require__) {

var isObject = __w_pdfjs_require__(23);
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");
};

/***/ }),
/* 23 */
/***/ (function(module, exports) {

module.exports = function (it) {
 return typeof it === 'object' ? it !== null : typeof it === 'function';
};

/***/ }),
/* 24 */
/***/ (function(module, exports) {

var hasOwnProperty = {}.hasOwnProperty;
module.exports = function (it, key) {
 return hasOwnProperty.call(it, key);
};

/***/ }),
/* 25 */
/***/ (function(module, exports, __w_pdfjs_require__) {

/***/ }),
/* 26 */
/***/ (function(module, exports, __w_pdfjs_require__) {

var global = __w_pdfjs_require__(12);
var isObject = __w_pdfjs_require__(23);
var document = global.document;
var EXISTS = isObject(document) && isObject(document.createElement);
module.exports = function (it) {
 return EXISTS ? document.createElement(it) : {};
};

/***/ }),
/* 27 */
/***/ (function(module, exports, __w_pdfjs_require__) {

var DESCRIPTORS = __w_pdfjs_require__(14);
var definePropertyModule = __w_pdfjs_require__(28);
var createPropertyDescriptor = __w_pdfjs_require__(17);
module.exports = DESCRIPTORS ? function (object, key, value) {
 return definePropertyModule.f(object, key, createPropertyDescriptor(1, value));
} : function (object, key, value) {
 object[key] = value;
 return object;
};

/***/ }),
/* 28 */
/***/ (function(module, exports, __w_pdfjs_require__) {

/***/ }),
/* 29 */
/***/ (function(module, exports, __w_pdfjs_require__) {

var isObject = __w_pdfjs_require__(23);
module.exports = function (it) {
 if (!isObject(it)) {
  throw TypeError(String(it) + ' is not an object');
 }
 return it;
};

/***/ }),
/* 30 */
/***/ (function(module, exports, __w_pdfjs_require__) {

/***/ }),
/* 31 */
/***/ (function(module, exports, __w_pdfjs_require__) {

/***/ }),
/* 32 */
/***/ (function(module, exports, __w_pdfjs_require__) {

/***/ }),
/* 33 */
/***/ (function(module, exports) {

module.exports = false;

/***/ }),
/* 34 */
/***/ (function(module, exports, __w_pdfjs_require__) {

var shared = __w_pdfjs_require__(31);
module.exports = shared('native-function-to-string', Function.toString);

/***/ }),
/* 35 */
/***/ (function(module, exports, __w_pdfjs_require__) {

/***/ }),
/* 36 */
/***/ (function(module, exports, __w_pdfjs_require__) {

var global = __w_pdfjs_require__(12);
var nativeFunctionToString = __w_pdfjs_require__(34);
var WeakMap = global.WeakMap;
module.exports = typeof WeakMap === 'function' && /native code/.test(nativeFunctionToString.call(WeakMap));

/***/ }),
/* 37 */
/***/ (function(module, exports, __w_pdfjs_require__) {

var shared = __w_pdfjs_require__(31);
var uid = __w_pdfjs_require__(38);
var keys = shared('keys');
module.exports = function (key) {
 return keys[key] || (keys[key] = uid(key));
};

/***/ }),
/* 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__(24);
var ownKeys = __w_pdfjs_require__(41);
var getOwnPropertyDescriptorModule = __w_pdfjs_require__(13);
var definePropertyModule = __w_pdfjs_require__(28);
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__(29);
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__(12);
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__) {

module.exports = __w_pdfjs_require__(12);

/***/ }),
/* 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__(24);
var toIndexedObject = __w_pdfjs_require__(18);
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__) {

/***/ }),
/* 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__) {

/***/ }),
/* 53 */
/***/ (function(module, exports, __w_pdfjs_require__) {

var isRegExp = __w_pdfjs_require__(54);
module.exports = function (it) {
 if (isRegExp(it)) {
  throw TypeError("The method doesn't accept regular expressions");
 }
 return it;
};

/***/ }),
/* 54 */
/***/ (function(module, exports, __w_pdfjs_require__) {

var isObject = __w_pdfjs_require__(23);
var classof = __w_pdfjs_require__(20);
var wellKnownSymbol = __w_pdfjs_require__(55);
var MATCH = wellKnownSymbol('match');
module.exports = function (it) {
 var isRegExp;
 return isObject(it) && ((isRegExp = it[MATCH]) !== undefined ? !!isRegExp : classof(it) == 'RegExp');
};

/***/ }),
/* 55 */
/***/ (function(module, exports, __w_pdfjs_require__) {

var global = __w_pdfjs_require__(12);
var shared = __w_pdfjs_require__(31);
var uid = __w_pdfjs_require__(38);
var NATIVE_SYMBOL = __w_pdfjs_require__(56);
var Symbol = global.Symbol;
var store = shared('wks');
module.exports = function (name) {
 return store[name] || (store[name] = NATIVE_SYMBOL && Symbol[name] || (NATIVE_SYMBOL ? Symbol : uid)('Symbol.' + name));
};

/***/ }),
/* 56 */
/***/ (function(module, exports, __w_pdfjs_require__) {

var fails = __w_pdfjs_require__(15);
module.exports = !!Object.getOwnPropertySymbols && !fails(function () {
 return !String(Symbol());
});

/***/ }),
/* 57 */
/***/ (function(module, exports, __w_pdfjs_require__) {

/***/ }),
/* 58 */
/***/ (function(module, exports, __w_pdfjs_require__) {

var global = __w_pdfjs_require__(12);
var bind = __w_pdfjs_require__(59);
var call = Function.call;
module.exports = function (CONSTRUCTOR, METHOD, length) {
 return bind(call, global[CONSTRUCTOR].prototype[METHOD], length);
};

/***/ }),
/* 59 */
/***/ (function(module, exports, __w_pdfjs_require__) {

/***/ }),
/* 60 */
/***/ (function(module, exports) {

module.exports = function (it) {
 if (typeof it != 'function') {
  throw TypeError(String(it) + ' is not a function');
 }
 return it;
};

/***/ }),
/* 61 */
/***/ (function(module, exports, __w_pdfjs_require__) {

__w_pdfjs_require__(62);
var entryUnbind = __w_pdfjs_require__(58);
module.exports = entryUnbind('String', 'endsWith');

/***/ }),
/* 62 */
/***/ (function(module, exports, __w_pdfjs_require__) {

"use strict";

/***/ }),
/* 63 */
/***/ (function(module, exports, __w_pdfjs_require__) {

__w_pdfjs_require__(64);
var entryUnbind = __w_pdfjs_require__(58);
module.exports = entryUnbind('String', 'includes');

/***/ }),
/* 64 */
/***/ (function(module, exports, __w_pdfjs_require__) {

"use strict";

/***/ }),
/* 65 */
/***/ (function(module, exports, __w_pdfjs_require__) {

__w_pdfjs_require__(66);
var entryUnbind = __w_pdfjs_require__(58);
module.exports = entryUnbind('Array', 'includes');

/***/ }),
/* 66 */
/***/ (function(module, exports, __w_pdfjs_require__) {

"use strict";

/***/ }),
/* 67 */
/***/ (function(module, exports, __w_pdfjs_require__) {

var wellKnownSymbol = __w_pdfjs_require__(55);
var create = __w_pdfjs_require__(68);
var hide = __w_pdfjs_require__(27);
var UNSCOPABLES = wellKnownSymbol('unscopables');
var ArrayPrototype = Array.prototype;
if (ArrayPrototype[UNSCOPABLES] == undefined) {
 hide(ArrayPrototype, UNSCOPABLES, create(null));
}
module.exports = function (key) {
 ArrayPrototype[UNSCOPABLES][key] = true;
};

/***/ }),
/* 68 */
/***/ (function(module, exports, __w_pdfjs_require__) {

/***/ }),
/* 69 */
/***/ (function(module, exports, __w_pdfjs_require__) {

var DESCRIPTORS = __w_pdfjs_require__(14);
var definePropertyModule = __w_pdfjs_require__(28);
var anObject = __w_pdfjs_require__(29);
var objectKeys = __w_pdfjs_require__(70);
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;
};

/***/ }),
/* 70 */
/***/ (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);
};

/***/ }),
/* 71 */
/***/ (function(module, exports, __w_pdfjs_require__) {

var getBuiltIn = __w_pdfjs_require__(42);
module.exports = getBuiltIn('document', 'documentElement');

/***/ }),
/* 72 */
/***/ (function(module, exports, __w_pdfjs_require__) {

__w_pdfjs_require__(73);
__w_pdfjs_require__(85);
var path = __w_pdfjs_require__(43);
module.exports = path.Array.from;

/***/ }),
/* 73 */
/***/ (function(module, exports, __w_pdfjs_require__) {

"use strict";

/***/ }),
/* 74 */
/***/ (function(module, exports, __w_pdfjs_require__) {

/***/ }),
/* 75 */
/***/ (function(module, exports, __w_pdfjs_require__) {

"use strict";

/***/ }),
/* 76 */
/***/ (function(module, exports, __w_pdfjs_require__) {

"use strict";

/***/ }),
/* 77 */
/***/ (function(module, exports, __w_pdfjs_require__) {

"use strict";

/***/ }),
/* 78 */
/***/ (function(module, exports, __w_pdfjs_require__) {

var has = __w_pdfjs_require__(24);
var toObject = __w_pdfjs_require__(79);
var sharedKey = __w_pdfjs_require__(37);
var CORRECT_PROTOTYPE_GETTER = __w_pdfjs_require__(80);
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;
};

/***/ }),
/* 79 */
/***/ (function(module, exports, __w_pdfjs_require__) {

var requireObjectCoercible = __w_pdfjs_require__(21);
module.exports = function (argument) {
 return Object(requireObjectCoercible(argument));
};

/***/ }),
/* 80 */
/***/ (function(module, exports, __w_pdfjs_require__) {

var fails = __w_pdfjs_require__(15);
module.exports = !fails(function () {
 function F() {
 }
 F.prototype.constructor = null;
 return Object.getPrototypeOf(new F()) !== F.prototype;
});

/***/ }),
/* 81 */
/***/ (function(module, exports, __w_pdfjs_require__) {

/***/ }),
/* 82 */
/***/ (function(module, exports) {

module.exports = {};

/***/ }),
/* 83 */
/***/ (function(module, exports, __w_pdfjs_require__) {

/***/ }),
/* 84 */
/***/ (function(module, exports, __w_pdfjs_require__) {

var isObject = __w_pdfjs_require__(23);
module.exports = function (it) {
 if (!isObject(it) && it !== null) {
  throw TypeError("Can't set " + String(it) + ' as a prototype');
 }
 return it;
};

/***/ }),
/* 85 */
/***/ (function(module, exports, __w_pdfjs_require__) {

/***/ }),
/* 86 */
/***/ (function(module, exports, __w_pdfjs_require__) {

"use strict";

/***/ }),
/* 87 */
/***/ (function(module, exports, __w_pdfjs_require__) {

/***/ }),
/* 88 */
/***/ (function(module, exports, __w_pdfjs_require__) {

var wellKnownSymbol = __w_pdfjs_require__(55);
var Iterators = __w_pdfjs_require__(82);
var ITERATOR = wellKnownSymbol('iterator');
var ArrayPrototype = Array.prototype;
module.exports = function (it) {
 return it !== undefined && (Iterators.Array === it || ArrayPrototype[ITERATOR] === it);
};

/***/ }),
/* 89 */
/***/ (function(module, exports, __w_pdfjs_require__) {

"use strict";

var toPrimitive = __w_pdfjs_require__(22);
var definePropertyModule = __w_pdfjs_require__(28);
var createPropertyDescriptor = __w_pdfjs_require__(17);
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;
};

/***/ }),
/* 90 */
/***/ (function(module, exports, __w_pdfjs_require__) {

var classof = __w_pdfjs_require__(91);
var Iterators = __w_pdfjs_require__(82);
var wellKnownSymbol = __w_pdfjs_require__(55);
var ITERATOR = wellKnownSymbol('iterator');
module.exports = function (it) {
 if (it != undefined)
  return it[ITERATOR] || it['@@iterator'] || Iterators[classof(it)];
};

/***/ }),
/* 91 */
/***/ (function(module, exports, __w_pdfjs_require__) {

/***/ }),
/* 92 */
/***/ (function(module, exports, __w_pdfjs_require__) {

/***/ }),
/* 93 */
/***/ (function(module, exports, __w_pdfjs_require__) {

__w_pdfjs_require__(94);
var path = __w_pdfjs_require__(43);
module.exports = path.Object.assign;

/***/ }),
/* 94 */
/***/ (function(module, exports, __w_pdfjs_require__) {

var $ = __w_pdfjs_require__(11);
var assign = __w_pdfjs_require__(95);
$({
 target: 'Object',
 stat: true,
 forced: Object.assign !== assign
}, { assign: assign });

/***/ }),
/* 95 */
/***/ (function(module, exports, __w_pdfjs_require__) {

"use strict";

/***/ }),
/* 96 */
/***/ (function(module, exports, __w_pdfjs_require__) {

__w_pdfjs_require__(97);
var path = __w_pdfjs_require__(43);
module.exports = path.Math.log2;

/***/ }),
/* 97 */
/***/ (function(module, exports, __w_pdfjs_require__) {

var $ = __w_pdfjs_require__(11);
var log = Math.log;
var LN2 = Math.LN2;
$({
 target: 'Math',
 stat: true
}, {
 log2: function log2(x) {
  return log(x) / LN2;
 }
});

/***/ }),
/* 98 */
/***/ (function(module, exports, __w_pdfjs_require__) {

__w_pdfjs_require__(99);
var path = __w_pdfjs_require__(43);
module.exports = path.Number.isNaN;

/***/ }),
/* 99 */
/***/ (function(module, exports, __w_pdfjs_require__) {

var $ = __w_pdfjs_require__(11);
$({
 target: 'Number',
 stat: true
}, {
 isNaN: function isNaN(number) {
  return number != number;
 }
});

/***/ }),
/* 100 */
/***/ (function(module, exports, __w_pdfjs_require__) {

__w_pdfjs_require__(101);
var path = __w_pdfjs_require__(43);
module.exports = path.Number.isInteger;

/***/ }),
/* 101 */
/***/ (function(module, exports, __w_pdfjs_require__) {

var $ = __w_pdfjs_require__(11);
var isInteger = __w_pdfjs_require__(102);
$({
 target: 'Number',
 stat: true
}, { isInteger: isInteger });

/***/ }),
/* 102 */
/***/ (function(module, exports, __w_pdfjs_require__) {

var isObject = __w_pdfjs_require__(23);
var floor = Math.floor;
module.exports = function isInteger(it) {
 return !isObject(it) && isFinite(it) && floor(it) === it;
};

/***/ }),
/* 103 */
/***/ (function(module, exports, __w_pdfjs_require__) {

__w_pdfjs_require__(104);
__w_pdfjs_require__(73);
__w_pdfjs_require__(106);
__w_pdfjs_require__(109);
__w_pdfjs_require__(123);
__w_pdfjs_require__(124);
var path = __w_pdfjs_require__(43);
module.exports = path.Promise;

/***/ }),
/* 104 */
/***/ (function(module, exports, __w_pdfjs_require__) {

var redefine = __w_pdfjs_require__(30);
var toString = __w_pdfjs_require__(105);
var ObjectPrototype = Object.prototype;
if (toString !== ObjectPrototype.toString) {
 redefine(ObjectPrototype, 'toString', toString, { unsafe: true });
}

/***/ }),
/* 105 */
/***/ (function(module, exports, __w_pdfjs_require__) {

"use strict";

var classof = __w_pdfjs_require__(91);
var wellKnownSymbol = __w_pdfjs_require__(55);
var TO_STRING_TAG = wellKnownSymbol('toStringTag');
var test = {};
test[TO_STRING_TAG] = 'z';
module.exports = String(test) !== '[object z]' ? function toString() {
 return '[object ' + classof(this) + ']';
} : test.toString;

/***/ }),
/* 106 */
/***/ (function(module, exports, __w_pdfjs_require__) {

/***/ }),
/* 107 */
/***/ (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
};

/***/ }),
/* 108 */
/***/ (function(module, exports, __w_pdfjs_require__) {

"use strict";

/***/ }),
/* 109 */
/***/ (function(module, exports, __w_pdfjs_require__) {

"use strict";

/***/ }),
/* 110 */
/***/ (function(module, exports, __w_pdfjs_require__) {

var global = __w_pdfjs_require__(12);
module.exports = global.Promise;

/***/ }),
/* 111 */
/***/ (function(module, exports, __w_pdfjs_require__) {

var redefine = __w_pdfjs_require__(30);
module.exports = function (target, src, options) {
 for (var key in src)
  redefine(target, key, src[key], options);
 return target;
};

/***/ }),
/* 112 */
/***/ (function(module, exports, __w_pdfjs_require__) {

"use strict";

/***/ }),
/* 113 */
/***/ (function(module, exports) {

module.exports = function (it, Constructor, name) {
 if (!(it instanceof Constructor)) {
  throw TypeError('Incorrect ' + (name ? name + ' ' : '') + 'invocation');
 }
 return it;
};

/***/ }),
/* 114 */
/***/ (function(module, exports, __w_pdfjs_require__) {

/***/ }),
/* 115 */
/***/ (function(module, exports, __w_pdfjs_require__) {

var anObject = __w_pdfjs_require__(29);
var aFunction = __w_pdfjs_require__(60);
var wellKnownSymbol = __w_pdfjs_require__(55);
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);
};

/***/ }),
/* 116 */
/***/ (function(module, exports, __w_pdfjs_require__) {

/***/ }),
/* 117 */
/***/ (function(module, exports, __w_pdfjs_require__) {

/***/ }),
/* 118 */
/***/ (function(module, exports, __w_pdfjs_require__) {

var getBuiltIn = __w_pdfjs_require__(42);
module.exports = getBuiltIn('navigator', 'userAgent') || '';

/***/ }),
/* 119 */
/***/ (function(module, exports, __w_pdfjs_require__) {

var anObject = __w_pdfjs_require__(29);
var isObject = __w_pdfjs_require__(23);
var newPromiseCapability = __w_pdfjs_require__(120);
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;
};

/***/ }),
/* 120 */
/***/ (function(module, exports, __w_pdfjs_require__) {

"use strict";

/***/ }),
/* 121 */
/***/ (function(module, exports, __w_pdfjs_require__) {

var global = __w_pdfjs_require__(12);
module.exports = function (a, b) {
 var console = global.console;
 if (console && console.error) {
  arguments.length === 1 ? console.error(a) : console.error(a, b);
 }
};

/***/ }),
/* 122 */
/***/ (function(module, exports) {

module.exports = function (exec) {
 try {
  return {
   error: false,
   value: exec()
  };
 } catch (error) {
  return {
   error: true,
   value: error
  };
 }
};

/***/ }),
/* 123 */
/***/ (function(module, exports, __w_pdfjs_require__) {

"use strict";

/***/ }),
/* 124 */
/***/ (function(module, exports, __w_pdfjs_require__) {

"use strict";

/***/ }),
/* 125 */
/***/ (function(module, exports, __w_pdfjs_require__) {

__w_pdfjs_require__(126);
__w_pdfjs_require__(131);
__w_pdfjs_require__(129);
var path = __w_pdfjs_require__(43);
module.exports = path.URL;

/***/ }),
/* 126 */
/***/ (function(module, exports, __w_pdfjs_require__) {

"use strict";

__w_pdfjs_require__(73);
var $ = __w_pdfjs_require__(11);
var DESCRIPTORS = __w_pdfjs_require__(14);
var USE_NATIVE_URL = __w_pdfjs_require__(127);
var global = __w_pdfjs_require__(12);
var defineProperties = __w_pdfjs_require__(69);
var redefine = __w_pdfjs_require__(30);
var anInstance = __w_pdfjs_require__(113);
var has = __w_pdfjs_require__(24);
var assign = __w_pdfjs_require__(95);
var arrayFrom = __w_pdfjs_require__(86);
var codeAt = __w_pdfjs_require__(74).codeAt;
var toASCII = __w_pdfjs_require__(128);
var setToStringTag = __w_pdfjs_require__(81);
var URLSearchParamsModule = __w_pdfjs_require__(129);
var InternalStateModule = __w_pdfjs_require__(35);
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,
 gopher: 70,
 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 });

/***/ }),
/* 127 */
/***/ (function(module, exports, __w_pdfjs_require__) {

var fails = __w_pdfjs_require__(15);
var wellKnownSymbol = __w_pdfjs_require__(55);
var IS_PURE = __w_pdfjs_require__(33);
var ITERATOR = wellKnownSymbol('iterator');
module.exports = !fails(function () {
 var url = new URL('b?e=1', 'http://a');
 var searchParams = url.searchParams;
 url.pathname = 'c%20d';
 return IS_PURE && !url.toJSON || !searchParams.sort || url.href !== 'http://a/c%20d?e=1' || searchParams.get('e') !== '1' || 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';
});

/***/ }),
/* 128 */
/***/ (function(module, exports, __w_pdfjs_require__) {

"use strict";

/***/ }),
/* 129 */
/***/ (function(module, exports, __w_pdfjs_require__) {

"use strict";

__w_pdfjs_require__(108);
var $ = __w_pdfjs_require__(11);
var USE_NATIVE_URL = __w_pdfjs_require__(127);
var redefine = __w_pdfjs_require__(30);
var redefineAll = __w_pdfjs_require__(111);
var setToStringTag = __w_pdfjs_require__(81);
var createIteratorConstructor = __w_pdfjs_require__(76);
var InternalStateModule = __w_pdfjs_require__(35);
var anInstance = __w_pdfjs_require__(113);
var hasOwn = __w_pdfjs_require__(24);
var bind = __w_pdfjs_require__(59);
var anObject = __w_pdfjs_require__(29);
var isObject = __w_pdfjs_require__(23);
var getIterator = __w_pdfjs_require__(130);
var getIteratorMethod = __w_pdfjs_require__(90);
var wellKnownSymbol = __w_pdfjs_require__(55);
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, step, entryIterator, 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);
    while (!(step = iterator.next()).done) {
     entryIterator = getIterator(anObject(step.value));
     if ((first = entryIterator.next()).done || (second = entryIterator.next()).done || !entryIterator.next().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 });
module.exports = {
 URLSearchParams: URLSearchParamsConstructor,
 getState: getInternalParamsState
};

/***/ }),
/* 130 */
/***/ (function(module, exports, __w_pdfjs_require__) {

var anObject = __w_pdfjs_require__(29);
var getIteratorMethod = __w_pdfjs_require__(90);
module.exports = function (it) {
 var iteratorMethod = getIteratorMethod(it);
 if (typeof iteratorMethod != 'function') {
  throw TypeError(String(it) + ' is not iterable');
 }
 return anObject(iteratorMethod.call(it));
};

/***/ }),
/* 131 */
/***/ (function(module, exports, __w_pdfjs_require__) {

"use strict";

var $ = __w_pdfjs_require__(11);
$({
 target: 'URL',
 proto: true,
 enumerable: true
}, {
 toJSON: function toJSON() {
  return URL.prototype.toString.call(this);
 }
});

/***/ }),
/* 132 */
/***/ (function(module, exports, __w_pdfjs_require__) {

__w_pdfjs_require__(104);
__w_pdfjs_require__(133);
__w_pdfjs_require__(106);
var path = __w_pdfjs_require__(43);
module.exports = path.WeakMap;

/***/ }),
/* 133 */
/***/ (function(module, exports, __w_pdfjs_require__) {

"use strict";

/***/ }),
/* 134 */
/***/ (function(module, exports, __w_pdfjs_require__) {

/***/ }),
/* 135 */
/***/ (function(module, exports, __w_pdfjs_require__) {

var fails = __w_pdfjs_require__(15);
module.exports = !fails(function () {
 return Object.isExtensible(Object.preventExtensions({}));
});

/***/ }),
/* 136 */
/***/ (function(module, exports, __w_pdfjs_require__) {

"use strict";

/***/ }),
/* 137 */
/***/ (function(module, exports, __w_pdfjs_require__) {

var isObject = __w_pdfjs_require__(23);
var setPrototypeOf = __w_pdfjs_require__(83);
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;
};

/***/ }),
/* 138 */
/***/ (function(module, exports, __w_pdfjs_require__) {

"use strict";

/***/ }),
/* 139 */
/***/ (function(module, exports, __w_pdfjs_require__) {

/***/ }),
/* 140 */
/***/ (function(module, exports, __w_pdfjs_require__) {

/***/ }),
/* 141 */
/***/ (function(module, exports, __w_pdfjs_require__) {

var classof = __w_pdfjs_require__(20);
module.exports = Array.isArray || function isArray(arg) {
 return classof(arg) == 'Array';
};

/***/ }),
/* 142 */
/***/ (function(module, exports, __w_pdfjs_require__) {

__w_pdfjs_require__(104);
__w_pdfjs_require__(143);
__w_pdfjs_require__(106);
var path = __w_pdfjs_require__(43);
module.exports = path.WeakSet;

/***/ }),
/* 143 */
/***/ (function(module, exports, __w_pdfjs_require__) {

"use strict";

var collection = __w_pdfjs_require__(136);
var collectionWeak = __w_pdfjs_require__(138);
collection('WeakSet', function (get) {
 return function WeakSet() {
  return get(this, arguments.length ? arguments[0] : undefined);
 };
}, collectionWeak, false, true);

/***/ }),
/* 144 */
/***/ (function(module, exports, __w_pdfjs_require__) {

__w_pdfjs_require__(145);
var entryUnbind = __w_pdfjs_require__(58);
module.exports = entryUnbind('String', 'codePointAt');

/***/ }),
/* 145 */
/***/ (function(module, exports, __w_pdfjs_require__) {

"use strict";

var $ = __w_pdfjs_require__(11);
var codeAt = __w_pdfjs_require__(74).codeAt;
$({
 target: 'String',
 proto: true
}, {
 codePointAt: function codePointAt(pos) {
  return codeAt(this, pos);
 }
});

/***/ }),
/* 146 */
/***/ (function(module, exports, __w_pdfjs_require__) {

__w_pdfjs_require__(147);
var path = __w_pdfjs_require__(43);
module.exports = path.String.fromCodePoint;

/***/ }),
/* 147 */
/***/ (function(module, exports, __w_pdfjs_require__) {

/***/ }),
/* 148 */
/***/ (function(module, exports, __w_pdfjs_require__) {

__w_pdfjs_require__(149);
__w_pdfjs_require__(104);
__w_pdfjs_require__(151);
__w_pdfjs_require__(155);
__w_pdfjs_require__(156);
__w_pdfjs_require__(157);
__w_pdfjs_require__(158);
__w_pdfjs_require__(159);
__w_pdfjs_require__(160);
__w_pdfjs_require__(161);
__w_pdfjs_require__(162);
__w_pdfjs_require__(163);
__w_pdfjs_require__(164);
__w_pdfjs_require__(165);
__w_pdfjs_require__(166);
__w_pdfjs_require__(167);
__w_pdfjs_require__(168);
__w_pdfjs_require__(169);
__w_pdfjs_require__(170);
var path = __w_pdfjs_require__(43);
module.exports = path.Symbol;

/***/ }),
/* 149 */
/***/ (function(module, exports, __w_pdfjs_require__) {

"use strict";

/***/ }),
/* 150 */
/***/ (function(module, exports, __w_pdfjs_require__) {

/***/ }),
/* 151 */
/***/ (function(module, exports, __w_pdfjs_require__) {

"use strict";

/***/ }),
/* 152 */
/***/ (function(module, exports, __w_pdfjs_require__) {

/***/ }),
/* 153 */
/***/ (function(module, exports, __w_pdfjs_require__) {

exports.f = __w_pdfjs_require__(55);

/***/ }),
/* 154 */
/***/ (function(module, exports, __w_pdfjs_require__) {

/***/ }),
/* 155 */
/***/ (function(module, exports, __w_pdfjs_require__) {

var defineWellKnownSymbol = __w_pdfjs_require__(154);
defineWellKnownSymbol('asyncIterator');

/***/ }),
/* 156 */
/***/ (function(module, exports, __w_pdfjs_require__) {

"use strict";

/***/ }),
/* 157 */
/***/ (function(module, exports, __w_pdfjs_require__) {

var defineWellKnownSymbol = __w_pdfjs_require__(154);
defineWellKnownSymbol('hasInstance');

/***/ }),
/* 158 */
/***/ (function(module, exports, __w_pdfjs_require__) {

var defineWellKnownSymbol = __w_pdfjs_require__(154);
defineWellKnownSymbol('isConcatSpreadable');

/***/ }),
/* 159 */
/***/ (function(module, exports, __w_pdfjs_require__) {

var defineWellKnownSymbol = __w_pdfjs_require__(154);
defineWellKnownSymbol('iterator');

/***/ }),
/* 160 */
/***/ (function(module, exports, __w_pdfjs_require__) {

var defineWellKnownSymbol = __w_pdfjs_require__(154);
defineWellKnownSymbol('match');

/***/ }),
/* 161 */
/***/ (function(module, exports, __w_pdfjs_require__) {

var defineWellKnownSymbol = __w_pdfjs_require__(154);
defineWellKnownSymbol('matchAll');

/***/ }),
/* 162 */
/***/ (function(module, exports, __w_pdfjs_require__) {

var defineWellKnownSymbol = __w_pdfjs_require__(154);
defineWellKnownSymbol('replace');

/***/ }),
/* 163 */
/***/ (function(module, exports, __w_pdfjs_require__) {

var defineWellKnownSymbol = __w_pdfjs_require__(154);
defineWellKnownSymbol('search');

/***/ }),
/* 164 */
/***/ (function(module, exports, __w_pdfjs_require__) {

var defineWellKnownSymbol = __w_pdfjs_require__(154);
defineWellKnownSymbol('species');

/***/ }),
/* 165 */
/***/ (function(module, exports, __w_pdfjs_require__) {

var defineWellKnownSymbol = __w_pdfjs_require__(154);
defineWellKnownSymbol('split');

/***/ }),
/* 166 */
/***/ (function(module, exports, __w_pdfjs_require__) {

var defineWellKnownSymbol = __w_pdfjs_require__(154);
defineWellKnownSymbol('toPrimitive');

/***/ }),
/* 167 */
/***/ (function(module, exports, __w_pdfjs_require__) {

var defineWellKnownSymbol = __w_pdfjs_require__(154);
defineWellKnownSymbol('toStringTag');

/***/ }),
/* 168 */
/***/ (function(module, exports, __w_pdfjs_require__) {

var defineWellKnownSymbol = __w_pdfjs_require__(154);
defineWellKnownSymbol('unscopables');

/***/ }),
/* 169 */
/***/ (function(module, exports, __w_pdfjs_require__) {

var setToStringTag = __w_pdfjs_require__(81);
setToStringTag(Math, 'Math', true);

/***/ }),
/* 170 */
/***/ (function(module, exports, __w_pdfjs_require__) {

var global = __w_pdfjs_require__(12);
var setToStringTag = __w_pdfjs_require__(81);
setToStringTag(global.JSON, 'JSON', true);

/***/ }),
/* 171 */
/***/ (function(module, exports, __w_pdfjs_require__) {

__w_pdfjs_require__(172);
var entryUnbind = __w_pdfjs_require__(58);
module.exports = entryUnbind('String', 'padStart');

/***/ }),
/* 172 */
/***/ (function(module, exports, __w_pdfjs_require__) {

"use strict";

/***/ }),
/* 173 */
/***/ (function(module, exports, __w_pdfjs_require__) {

/***/ }),
/* 174 */
/***/ (function(module, exports, __w_pdfjs_require__) {

"use strict";

var toInteger = __w_pdfjs_require__(48);
var requireObjectCoercible = __w_pdfjs_require__(21);
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;
};

/***/ }),
/* 175 */
/***/ (function(module, exports, __w_pdfjs_require__) {

var userAgent = __w_pdfjs_require__(118);
module.exports = /Version\/10\.\d+(\.\d+)?( Mobile\/\w+)? Safari\//.test(userAgent);

/***/ }),
/* 176 */
/***/ (function(module, exports, __w_pdfjs_require__) {

__w_pdfjs_require__(177);
var entryUnbind = __w_pdfjs_require__(58);
module.exports = entryUnbind('String', 'padEnd');

/***/ }),
/* 177 */
/***/ (function(module, exports, __w_pdfjs_require__) {

"use strict";

/***/ }),
/* 178 */
/***/ (function(module, exports, __w_pdfjs_require__) {

__w_pdfjs_require__(179);
var path = __w_pdfjs_require__(43);
module.exports = path.Object.values;

/***/ }),
/* 179 */
/***/ (function(module, exports, __w_pdfjs_require__) {

var $ = __w_pdfjs_require__(11);
var $values = __w_pdfjs_require__(180).values;
$({
 target: 'Object',
 stat: true
}, {
 values: function values(O) {
  return $values(O);
 }
});

/***/ }),
/* 180 */
/***/ (function(module, exports, __w_pdfjs_require__) {

/***/ }),
/* 181 */
/***/ (function(module, exports, __w_pdfjs_require__) {

"use strict";

{
  var isReadableStreamSupported = false;

if (typeof ReadableStream !== 'undefined') {
    try {
      new ReadableStream({
        start: function start(controller) {
          controller.close();
        }
      });
      isReadableStreamSupported = true;
    } catch (e) {}
  }

if (isReadableStreamSupported) {
    exports.ReadableStream = ReadableStream;
  } else {
    exports.ReadableStream = __w_pdfjs_require__(182).ReadableStream;
  }
}

/***/ }),
/* 182 */
/***/ (function(__webpack_module__, __webpack_exports__, __w_pdfjs_require__) {

"use strict";
__w_pdfjs_require__.r(__webpack_exports__);
/* harmony export (binding) */ __w_pdfjs_require__.d(__webpack_exports__, "ByteLengthQueuingStrategy", function() { return ByteLengthQueuingStrategy; });
/* harmony export (binding) */ __w_pdfjs_require__.d(__webpack_exports__, "CountQueuingStrategy", function() { return CountQueuingStrategy; });
/* harmony export (binding) */ __w_pdfjs_require__.d(__webpack_exports__, "ReadableStream", function() { return ReadableStream; });
/* harmony export (binding) */ __w_pdfjs_require__.d(__webpack_exports__, "TransformStream", function() { return TransformStream; });
/* harmony export (binding) */ __w_pdfjs_require__.d(__webpack_exports__, "WritableStream", function() { return WritableStream; });
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;
};
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 Promise.resolve();
 };
}
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 Promise.resolve(Call(F, V, args));
 } catch (value) {
  return Promise.reject(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 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 = new Promise(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) {
 reader._closedPromise.catch(noop);
 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 = new Promise(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 Promise.reject(defaultReaderBrandCheckException('closed'));
   }
   return this._closedPromise;
  },
  enumerable: true,
  configurable: true
 });
 ReadableStreamDefaultReader.prototype.cancel = function (reason) {
  if (!IsReadableStreamDefaultReader(this)) {
   return Promise.reject(defaultReaderBrandCheckException('cancel'));
  }
  if (this._ownerReadableStream === undefined) {
   return Promise.reject(readerLockException('cancel'));
  }
  return ReadableStreamReaderGenericCancel(this, reason);
 };
 ReadableStreamDefaultReader.prototype.read = function () {
  if (!IsReadableStreamDefaultReader(this)) {
   return Promise.reject(defaultReaderBrandCheckException('read'));
  }
  if (this._ownerReadableStream === undefined) {
   return Promise.reject(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 Promise.resolve(ReadableStreamCreateReadResult(undefined, true, reader._forAuthorCode));
 }
 if (stream._state === 'errored') {
  return Promise.reject(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 Promise.reject(streamAsyncIteratorBrandCheckException('next'));
  }
  var reader = this._asyncIteratorReader;
  if (reader._ownerReadableStream === undefined) {
   return Promise.reject(readerLockException('iterate'));
  }
  return ReadableStreamDefaultReaderRead(reader).then(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 Promise.reject(streamAsyncIteratorBrandCheckException('next'));
  }
  var reader = this._asyncIteratorReader;
  if (reader._ownerReadableStream === undefined) {
   return Promise.reject(readerLockException('finish iterating'));
  }
  if (reader._readRequests.length > 0) {
   return Promise.reject(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 result.then(function () {
    return ReadableStreamCreateReadResult(value, true, true);
   });
  }
  ReadableStreamReaderGenericRelease(reader);
  return Promise.resolve(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");
}
var rethrowAssertionErrorRejection = noop;
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 Promise.reject(streamBrandCheckException('abort'));
  }
  if (IsWritableStreamLocked(this) === true) {
   return Promise.reject(new TypeError('Cannot abort a stream that already has a writer'));
  }
  return WritableStreamAbort(this, reason);
 };
 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 Promise.resolve(undefined);
 }
 if (stream._pendingAbortRequest !== undefined) {
  return stream._pendingAbortRequest._promise;
 }
 var wasAlreadyErroring = false;
 if (state === 'erroring') {
  wasAlreadyErroring = true;
  reason = undefined;
 }
 var promise = new Promise(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 WritableStreamAddWriteRequest(stream) {
 var promise = new Promise(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);
 promise.then(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 Promise.reject(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 Promise.reject(defaultWriterBrandCheckException('ready'));
   }
   return this._readyPromise;
  },
  enumerable: true,
  configurable: true
 });
 WritableStreamDefaultWriter.prototype.abort = function (reason) {
  if (IsWritableStreamDefaultWriter(this) === false) {
   return Promise.reject(defaultWriterBrandCheckException('abort'));
  }
  if (this._ownerWritableStream === undefined) {
   return Promise.reject(defaultWriterLockException('abort'));
  }
  return WritableStreamDefaultWriterAbort(this, reason);
 };
 WritableStreamDefaultWriter.prototype.close = function () {
  if (IsWritableStreamDefaultWriter(this) === false) {
   return Promise.reject(defaultWriterBrandCheckException('close'));
  }
  var stream = this._ownerWritableStream;
  if (stream === undefined) {
   return Promise.reject(defaultWriterLockException('close'));
  }
  if (WritableStreamCloseQueuedOrInFlight(stream) === true) {
   return Promise.reject(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 Promise.reject(defaultWriterBrandCheckException('write'));
  }
  if (this._ownerWritableStream === undefined) {
   return Promise.reject(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;
 var state = stream._state;
 if (state === 'closed' || state === 'errored') {
  return Promise.reject(new TypeError("The stream (in " + state + " state) is not in the writable state and cannot be closed"));
 }
 var promise = new Promise(function (resolve, reject) {
  var closeRequest = {
   _resolve: resolve,
   _reject: reject
  };
  stream._closeRequest = closeRequest;
 });
 if (stream._backpressure === true && state === 'writable') {
  defaultWriterReadyPromiseResolve(writer);
 }
 WritableStreamDefaultControllerClose(stream._writableStreamController);
 return promise;
}
function WritableStreamDefaultWriterCloseWithErrorPropagation(writer) {
 var stream = writer._ownerWritableStream;
 var state = stream._state;
 if (WritableStreamCloseQueuedOrInFlight(stream) === true || state === 'closed') {
  return Promise.resolve();
 }
 if (state === 'errored') {
  return Promise.reject(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 Promise.reject(defaultWriterLockException('write to'));
 }
 var state = stream._state;
 if (state === 'errored') {
  return Promise.reject(stream._storedError);
 }
 if (WritableStreamCloseQueuedOrInFlight(stream) === true || state === 'closed') {
  return Promise.reject(new TypeError('The stream is closing or closed and cannot be written to'));
 }
 if (state === 'erroring') {
  return Promise.reject(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 = Promise.resolve(startResult);
 startPromise.then(function () {
  controller._started = true;
  WritableStreamDefaultControllerAdvanceQueueIfNeeded(controller);
 }, function (r) {
  controller._started = true;
  WritableStreamDealWithRejection(stream, r);
 }).catch(rethrowAssertionErrorRejection);
}
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);
 sinkClosePromise.then(function () {
  WritableStreamFinishInFlightClose(stream);
 }, function (reason) {
  WritableStreamFinishInFlightCloseWithError(stream, reason);
 }).catch(rethrowAssertionErrorRejection);
}
function WritableStreamDefaultControllerProcessWrite(controller, chunk) {
 var stream = controller._controlledWritableStream;
 WritableStreamMarkFirstWriteRequestInFlight(stream);
 var sinkWritePromise = controller._writeAlgorithm(chunk);
 sinkWritePromise.then(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);
 }).catch(rethrowAssertionErrorRejection);
}
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 = new Promise(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) {
 writer._closedPromise.catch(noop);
 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 = new Promise(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) {
 writer._readyPromise.catch(noop);
 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 ReadableStreamPipeTo(source, dest, preventClose, preventAbort, preventCancel, signal) {
 var reader = AcquireReadableStreamDefaultReader(source);
 var writer = AcquireWritableStreamDefaultWriter(dest);
 var shuttingDown = false;
 var currentWrite = Promise.resolve();
 return new Promise(function (resolve, reject) {
  var abortAlgorithm;
  if (signal !== undefined) {
   abortAlgorithm = function () {
    var error = new DOMException('Aborted', 'AbortError');
    var actions = [];
    if (preventAbort === false) {
     actions.push(function () {
      if (dest._state === 'writable') {
       return WritableStreamAbort(dest, error);
      }
      return Promise.resolve();
     });
    }
    if (preventCancel === false) {
     actions.push(function () {
      if (source._state === 'readable') {
       return ReadableStreamCancel(source, error);
      }
      return Promise.resolve();
     });
    }
    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 new Promise(function (resolveLoop, rejectLoop) {
    function next(done) {
     if (done) {
      resolveLoop();
     } else {
      pipeStep().then(next, rejectLoop);
     }
    }
    next(false);
   });
  }
  function pipeStep() {
   if (shuttingDown === true) {
    return Promise.resolve(true);
   }
   return writer._readyPromise.then(function () {
    return ReadableStreamDefaultReaderRead(reader).then(function (_a) {
     var value = _a.value, done = _a.done;
     if (done === true) {
      return true;
     }
     currentWrite = WritableStreamDefaultWriterWrite(writer, value).catch(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);
   }
  }
  pipeLoop().catch(rethrowAssertionErrorRejection);
  function waitForWritesToFinish() {
   var oldCurrentWrite = currentWrite;
   return currentWrite.then(function () {
    return oldCurrentWrite !== currentWrite ? waitForWritesToFinish() : undefined;
   });
  }
  function isOrBecomesErrored(stream, promise, action) {
   if (stream._state === 'errored') {
    action(stream._storedError);
   } else {
    promise.catch(action).catch(rethrowAssertionErrorRejection);
   }
  }
  function isOrBecomesClosed(stream, promise, action) {
   if (stream._state === 'closed') {
    action();
   } else {
    promise.then(action).catch(rethrowAssertionErrorRejection);
   }
  }
  function shutdownWithAction(action, originalIsError, originalError) {
   if (shuttingDown === true) {
    return;
   }
   shuttingDown = true;
   if (dest._state === 'writable' && WritableStreamCloseQueuedOrInFlight(dest) === false) {
    waitForWritesToFinish().then(doTheRest);
   } else {
    doTheRest();
   }
   function doTheRest() {
    action().then(function () {
     return finalize(originalIsError, originalError);
    }, function (newError) {
     return finalize(true, newError);
    }).catch(rethrowAssertionErrorRejection);
   }
  }
  function shutdown(isError, error) {
   if (shuttingDown === true) {
    return;
   }
   shuttingDown = true;
   if (dest._state === 'writable' && WritableStreamCloseQueuedOrInFlight(dest) === false) {
    waitForWritesToFinish().then(function () {
     return finalize(isError, error);
    }).catch(rethrowAssertionErrorRejection);
   } 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 Promise.resolve(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();
 pullPromise.then(function () {
  controller._pulling = false;
  if (controller._pullAgain === true) {
   controller._pullAgain = false;
   ReadableStreamDefaultControllerCallPullIfNeeded(controller);
  }
 }, function (e) {
  ReadableStreamDefaultControllerError(controller, e);
 }).catch(rethrowAssertionErrorRejection);
}
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();
 Promise.resolve(startResult).then(function () {
  controller._started = true;
  ReadableStreamDefaultControllerCallPullIfNeeded(controller);
 }, function (r) {
  ReadableStreamDefaultControllerError(controller, r);
 }).catch(rethrowAssertionErrorRejection);
}
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 = new Promise(function (resolve) {
  resolveCancelPromise = resolve;
 });
 function pullAlgorithm() {
  if (reading === true) {
   return Promise.resolve();
  }
  reading = true;
  var readPromise = ReadableStreamDefaultReaderRead(reader).then(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);
   }
  });
  readPromise.catch(rethrowAssertionErrorRejection);
  return Promise.resolve();
 }
 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);
 reader._closedPromise.catch(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 Promise.reject(viewE);
   }
   return Promise.resolve(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 Promise.reject(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();
 pullPromise.then(function () {
  controller._pulling = false;
  if (controller._pullAgain === true) {
   controller._pullAgain = false;
   ReadableByteStreamControllerCallPullIfNeeded(controller);
  }
 }, function (e) {
  ReadableByteStreamControllerError(controller, e);
 }).catch(rethrowAssertionErrorRejection);
}
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 Promise.resolve(ReadableStreamCreateReadResult(emptyView, true, stream._reader._forAuthorCode));
 }
 if (controller._queueTotalSize > 0) {
  if (ReadableByteStreamControllerFillPullIntoDescriptorFromQueue(controller, pullIntoDescriptor) === true) {
   var filledView = ReadableByteStreamControllerConvertPullIntoDescriptor(pullIntoDescriptor);
   ReadableByteStreamControllerHandleQueueDrain(controller);
   return Promise.resolve(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 Promise.reject(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();
 Promise.resolve(startResult).then(function () {
  controller._started = true;
  ReadableByteStreamControllerCallPullIfNeeded(controller);
 }, function (r) {
  ReadableByteStreamControllerError(controller, r);
 }).catch(rethrowAssertionErrorRejection);
}
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 = new Promise(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 Promise.reject(byobReaderBrandCheckException('closed'));
   }
   return this._closedPromise;
  },
  enumerable: true,
  configurable: true
 });
 ReadableStreamBYOBReader.prototype.cancel = function (reason) {
  if (!IsReadableStreamBYOBReader(this)) {
   return Promise.reject(byobReaderBrandCheckException('cancel'));
  }
  if (this._ownerReadableStream === undefined) {
   return Promise.reject(readerLockException('cancel'));
  }
  return ReadableStreamReaderGenericCancel(this, reason);
 };
 ReadableStreamBYOBReader.prototype.read = function (view) {
  if (!IsReadableStreamBYOBReader(this)) {
   return Promise.reject(byobReaderBrandCheckException('read'));
  }
  if (this._ownerReadableStream === undefined) {
   return Promise.reject(readerLockException('read from'));
  }
  if (!ArrayBuffer.isView(view)) {
   return Promise.reject(new TypeError('view must be an array buffer view'));
  }
  if (IsDetachedBuffer(view.buffer) === true);
  if (view.byteLength === 0) {
   return Promise.reject(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 Promise.reject(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 Promise.reject(streamBrandCheckException$1('cancel'));
  }
  if (IsReadableStreamLocked(this) === true) {
   return Promise.reject(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);
  promise.catch(noop);
  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 Promise.reject(streamBrandCheckException$1('pipeTo'));
  }
  if (IsWritableStream(dest) === false) {
   return Promise.reject(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 Promise.reject(new TypeError('ReadableStream.prototype.pipeTo\'s signal option must be an AbortSignal'));
  }
  if (IsReadableStreamLocked(this) === true) {
   return Promise.reject(new TypeError('ReadableStream.prototype.pipeTo cannot be used on a locked ReadableStream'));
  }
  if (IsWritableStreamLocked(dest) === true) {
   return Promise.reject(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 Promise.resolve(undefined);
 }
 if (stream._state === 'errored') {
  return Promise.reject(stream._storedError);
 }
 ReadableStreamClose(stream);
 var sourceCancelPromise = stream._readableStreamController[CancelSteps](reason);
 return sourceCancelPromise.then(function () {
  return undefined;
 });
}
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 isAbortSignal(value) {
 if (typeof value !== 'object' || value === null) {
  return false;
 }
 var aborted = Object.getOwnPropertyDescriptor(AbortSignal.prototype, 'aborted').get;
 try {
  aborted.call(value);
  return true;
 } catch (e) {
  return false;
 }
}
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 = new Promise(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 Promise.resolve();
 }
 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 = new Promise(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 Promise.resolve();
  } catch (transformResultE) {
   return Promise.reject(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 transformPromise.catch(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 backpressureChangePromise.then(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 Promise.resolve();
}
function TransformStreamDefaultSinkCloseAlgorithm(stream) {
 var readable = stream._readable;
 var controller = stream._transformStreamController;
 var flushPromise = controller._flushAlgorithm();
 TransformStreamDefaultControllerClearAlgorithms(controller);
 return flushPromise.then(function () {
  if (readable._state === 'errored') {
   throw readable._storedError;
  }
  var readableController = readable._readableStreamController;
  if (ReadableStreamDefaultControllerCanCloseOrEnqueue(readableController) === true) {
   ReadableStreamDefaultControllerClose(readableController);
  }
 }).catch(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");
}

/***/ }),
/* 183 */
/***/ (function(module, exports, __w_pdfjs_require__) {

"use strict";

Object.defineProperty(exports, "__esModule", {
  value: true
});
exports.clearPrimitiveCaches = clearPrimitiveCaches;
exports.isEOF = isEOF;
exports.isCmd = isCmd;
exports.isDict = isDict;
exports.isName = isName;
exports.isRef = isRef;
exports.isRefsEqual = isRefsEqual;
exports.isStream = isStream;
exports.RefSetCache = exports.RefSet = exports.Ref = exports.Name = exports.Dict = exports.Cmd = exports.EOF = void 0;

var _regenerator = _interopRequireDefault(__w_pdfjs_require__(2));

var _util = __w_pdfjs_require__(5);

function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { "default": obj }; }

var EOF = {};
exports.EOF = EOF;

var Name = function NameClosure() {
  var nameCache = Object.create(null);

function Name(name) {
    this.name = name;
  }

Name.prototype = {};

Name.get = function Name_get(name) {
    var nameValue = nameCache[name];
    return nameValue ? nameValue : nameCache[name] = new Name(name);
  };

Name._clearCache = function () {
    nameCache = Object.create(null);
  };

return Name;
}();

exports.Name = Name;

var Cmd = function CmdClosure() {
  var cmdCache = Object.create(null);

function Cmd(cmd) {
    this.cmd = cmd;
  }

Cmd.prototype = {};

Cmd.get = function Cmd_get(cmd) {
    var cmdValue = cmdCache[cmd];
    return cmdValue ? cmdValue : cmdCache[cmd] = new Cmd(cmd);
  };

Cmd._clearCache = function () {
    cmdCache = Object.create(null);
  };

return Cmd;
}();

exports.Cmd = Cmd;

var Dict = function DictClosure() {
  var nonSerializable = function nonSerializableClosure() {
    return nonSerializable;
  };

function Dict(xref) {
    this._map = Object.create(null);
    this.xref = xref;
    this.objId = null;
    this.suppressEncryption = false;
    this.__nonSerializable__ = nonSerializable;
  }

Dict.prototype = {
    assignXref: function Dict_assignXref(newXref) {
      this.xref = newXref;
    },
    get: function get(key1, key2, key3) {
      var value = this._map[key1];

if (value === undefined && !(key1 in this._map) && key2 !== undefined) {
        value = this._map[key2];

if (value === undefined && !(key2 in this._map) && key3 !== undefined) {
          value = this._map[key3];
        }
      }

if (value instanceof Ref && this.xref) {
        return this.xref.fetch(value, this.suppressEncryption);
      }

return value;
    },
    getAsync: function () {
      var _getAsync = _asyncToGenerator(
      /*#__PURE__*/
      _regenerator["default"].mark(function _callee(key1, key2, key3) {
        var value;
        return _regenerator["default"].wrap(function _callee$(_context) {
          while (1) {
            switch (_context.prev = _context.next) {
              case 0:
                value = this._map[key1];

if (value === undefined && !(key1 in this._map) && key2 !== undefined) {
                  value = this._map[key2];

if (value === undefined && !(key2 in this._map) && key3 !== undefined) {
                    value = this._map[key3];
                  }
                }

if (!(value instanceof Ref && this.xref)) {
                  _context.next = 4;
                  break;
                }

return _context.abrupt("return", this.xref.fetchAsync(value, this.suppressEncryption));

case 4:
                return _context.abrupt("return", value);

case 5:
              case "end":
                return _context.stop();
            }
          }
        }, _callee, this);
      }));

function getAsync(_x, _x2, _x3) {
        return _getAsync.apply(this, arguments);
      }

return getAsync;
    }(),
    getArray: function getArray(key1, key2, key3) {
      var value = this.get(key1, key2, key3);

if (!Array.isArray(value) || !this.xref) {
        return value;
      }

value = value.slice();

for (var i = 0, ii = value.length; i < ii; i++) {
        if (!(value[i] instanceof Ref)) {
          continue;
        }

value[i] = this.xref.fetch(value[i], this.suppressEncryption);
      }

return value;
    },
    getRaw: function Dict_getRaw(key) {
      return this._map[key];
    },
    getKeys: function Dict_getKeys() {
      return Object.keys(this._map);
    },
    set: function Dict_set(key, value) {
      this._map[key] = value;
    },
    has: function Dict_has(key) {
      return key in this._map;
    },
    forEach: function Dict_forEach(callback) {
      for (var key in this._map) {
        callback(key, this.get(key));
      }
    }
  };
  Dict.empty = new Dict(null);

Dict.merge = function (xref, dictArray) {
    var mergedDict = new Dict(xref);

for (var i = 0, ii = dictArray.length; i < ii; i++) {
      var dict = dictArray[i];

if (!isDict(dict)) {
        continue;
      }

for (var keyName in dict._map) {
        if (mergedDict._map[keyName] !== undefined) {
          continue;
        }

mergedDict._map[keyName] = dict._map[keyName];
      }
    }

return mergedDict;
  };

return Dict;
}();

exports.Dict = Dict;

var Ref = function RefClosure() {
  var refCache = Object.create(null);

function Ref(num, gen) {
    this.num = num;
    this.gen = gen;
  }

Ref.prototype = {
    toString: function Ref_toString() {
      if (this.gen === 0) {
        return "".concat(this.num, "R");
      }

return "".concat(this.num, "R").concat(this.gen);
    }
  };

Ref.get = function (num, gen) {
    var key = gen === 0 ? "".concat(num, "R") : "".concat(num, "R").concat(gen);
    var refValue = refCache[key];
    return refValue ? refValue : refCache[key] = new Ref(num, gen);
  };

Ref._clearCache = function () {
    refCache = Object.create(null);
  };

return Ref;
}();

exports.Ref = Ref;

var RefSet = function RefSetClosure() {
  function RefSet() {
    this.dict = Object.create(null);
  }

RefSet.prototype = {
    has: function RefSet_has(ref) {
      return ref.toString() in this.dict;
    },
    put: function RefSet_put(ref) {
      this.dict[ref.toString()] = true;
    },
    remove: function RefSet_remove(ref) {
      delete this.dict[ref.toString()];
    }
  };
  return RefSet;
}();

exports.RefSet = RefSet;

var RefSetCache = function RefSetCacheClosure() {
  function RefSetCache() {
    this.dict = Object.create(null);
  }

RefSetCache.prototype = {
    get: function RefSetCache_get(ref) {
      return this.dict[ref.toString()];
    },
    has: function RefSetCache_has(ref) {
      return ref.toString() in this.dict;
    },
    put: function RefSetCache_put(ref, obj) {
      this.dict[ref.toString()] = obj;
    },
    putAlias: function RefSetCache_putAlias(ref, aliasRef) {
      this.dict[ref.toString()] = this.get(aliasRef);
    },
    forEach: function RefSetCache_forEach(fn, thisArg) {
      for (var i in this.dict) {
        fn.call(thisArg, this.dict[i]);
      }
    },
    clear: function RefSetCache_clear() {
      this.dict = Object.create(null);
    }
  };
  return RefSetCache;
}();

exports.RefSetCache = RefSetCache;

function isEOF(v) {
  return v === EOF;
}

function isName(v, name) {
  return v instanceof Name && (name === undefined || v.name === name);
}

function isCmd(v, cmd) {
  return v instanceof Cmd && (cmd === undefined || v.cmd === cmd);
}

function isDict(v, type) {
  return v instanceof Dict && (type === undefined || isName(v.get('Type'), type));
}

function isRef(v) {
  return v instanceof Ref;
}

function isRefsEqual(v1, v2) {
  return v1.num === v2.num && v1.gen === v2.gen;
}

function isStream(v) {
  return _typeof(v) === 'object' && v !== null && v.getBytes !== undefined;
}

function clearPrimitiveCaches() {
  Cmd._clearCache();

Name._clearCache();

Ref._clearCache();
}

/***/ }),
/* 184 */
/***/ (function(module, exports, __w_pdfjs_require__) {

"use strict";

Object.defineProperty(exports, "__esModule", {
  value: true
});
exports.NetworkPdfManager = exports.LocalPdfManager = void 0;

var _regenerator = _interopRequireDefault(__w_pdfjs_require__(2));

var _util = __w_pdfjs_require__(5);

var _chunked_stream = __w_pdfjs_require__(185);

var _core_utils = __w_pdfjs_require__(186);

var _document = __w_pdfjs_require__(187);

var _stream = __w_pdfjs_require__(190);

function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { "default": obj }; }

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 _setPrototypeOf(o, p) { _setPrototypeOf = Object.setPrototypeOf || function _setPrototypeOf(o, p) { o.__proto__ = p; return o; }; return _setPrototypeOf(o, p); }

function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }

var BasePdfManager =
/*#__PURE__*/
function () {
  function BasePdfManager() {
    _classCallCheck(this, BasePdfManager);

if (this.constructor === BasePdfManager) {
      (0, _util.unreachable)('Cannot initialize BasePdfManager.');
    }
  }

_createClass(BasePdfManager, [{
    key: "onLoadedStream",
    value: function onLoadedStream() {
      (0, _util.unreachable)('Abstract method `onLoadedStream` called');
    }
  }, {
    key: "ensureDoc",
    value: function ensureDoc(prop, args) {
      return this.ensure(this.pdfDocument, prop, args);
    }
  }, {
    key: "ensureXRef",
    value: function ensureXRef(prop, args) {
      return this.ensure(this.pdfDocument.xref, prop, args);
    }
  }, {
    key: "ensureCatalog",
    value: function ensureCatalog(prop, args) {
      return this.ensure(this.pdfDocument.catalog, prop, args);
    }
  }, {
    key: "getPage",
    value: function getPage(pageIndex) {
      return this.pdfDocument.getPage(pageIndex);
    }
  }, {
    key: "fontFallback",
    value: function fontFallback(id, handler) {
      return this.pdfDocument.fontFallback(id, handler);
    }
  }, {
    key: "cleanup",
    value: function cleanup() {
      return this.pdfDocument.cleanup();
    }
  }, {
    key: "ensure",
    value: function () {
      var _ensure = _asyncToGenerator(
      /*#__PURE__*/
      _regenerator["default"].mark(function _callee(obj, prop, args) {
        return _regenerator["default"].wrap(function _callee$(_context) {
          while (1) {
            switch (_context.prev = _context.next) {
              case 0:
                (0, _util.unreachable)('Abstract method `ensure` called');

case 1:
              case "end":
                return _context.stop();
            }
          }
        }, _callee);
      }));

function ensure(_x, _x2, _x3) {
        return _ensure.apply(this, arguments);
      }

return ensure;
    }()
  }, {
    key: "requestRange",
    value: function requestRange(begin, end) {
      (0, _util.unreachable)('Abstract method `requestRange` called');
    }
  }, {
    key: "requestLoadedStream",
    value: function requestLoadedStream() {
      (0, _util.unreachable)('Abstract method `requestLoadedStream` called');
    }
  }, {
    key: "sendProgressiveData",
    value: function sendProgressiveData(chunk) {
      (0, _util.unreachable)('Abstract method `sendProgressiveData` called');
    }
  }, {
    key: "updatePassword",
    value: function updatePassword(password) {
      this._password = password;
    }
  }, {
    key: "terminate",
    value: function terminate(reason) {
      (0, _util.unreachable)('Abstract method `terminate` called');
    }
  }, {
    key: "docId",
    get: function get() {
      return this._docId;
    }
  }, {
    key: "password",
    get: function get() {
      return this._password;
    }
  }, {
    key: "docBaseUrl",
    get: function get() {
      var docBaseUrl = null;

if (this._docBaseUrl) {
        var absoluteUrl = (0, _util.createValidAbsoluteUrl)(this._docBaseUrl);

if (absoluteUrl) {
          docBaseUrl = absoluteUrl.href;
        } else {
          (0, _util.warn)("Invalid absolute docBaseUrl: \"".concat(this._docBaseUrl, "\"."));
        }
      }

return (0, _util.shadow)(this, 'docBaseUrl', docBaseUrl);
    }
  }]);

return BasePdfManager;
}();

var LocalPdfManager =
/*#__PURE__*/
function (_BasePdfManager) {
  _inherits(LocalPdfManager, _BasePdfManager);

function LocalPdfManager(docId, data, password, evaluatorOptions, docBaseUrl) {
    var _this;

_classCallCheck(this, LocalPdfManager);

_this = _possibleConstructorReturn(this, _getPrototypeOf(LocalPdfManager).call(this));
    _this._docId = docId;
    _this._password = password;
    _this._docBaseUrl = docBaseUrl;
    _this.evaluatorOptions = evaluatorOptions;
    var stream = new _stream.Stream(data);
    _this.pdfDocument = new _document.PDFDocument(_assertThisInitialized(_this), stream);
    _this._loadedStreamPromise = Promise.resolve(stream);
    return _this;
  }

_createClass(LocalPdfManager, [{
    key: "ensure",
    value: function () {
      var _ensure2 = _asyncToGenerator(
      /*#__PURE__*/
      _regenerator["default"].mark(function _callee2(obj, prop, args) {
        var value;
        return _regenerator["default"].wrap(function _callee2$(_context2) {
          while (1) {
            switch (_context2.prev = _context2.next) {
              case 0:
                value = obj[prop];

if (!(typeof value === 'function')) {
                  _context2.next = 3;
                  break;
                }

return _context2.abrupt("return", value.apply(obj, args));

case 3:
                return _context2.abrupt("return", value);

case 4:
              case "end":
                return _context2.stop();
            }
          }
        }, _callee2);
      }));

function ensure(_x4, _x5, _x6) {
        return _ensure2.apply(this, arguments);
      }

return ensure;
    }()
  }, {
    key: "requestRange",
    value: function requestRange(begin, end) {
      return Promise.resolve();
    }
  }, {
    key: "requestLoadedStream",
    value: function requestLoadedStream() {}
  }, {
    key: "onLoadedStream",
    value: function onLoadedStream() {
      return this._loadedStreamPromise;
    }
  }, {
    key: "terminate",
    value: function terminate(reason) {}
  }]);

return LocalPdfManager;
}(BasePdfManager);

exports.LocalPdfManager = LocalPdfManager;

var NetworkPdfManager =
/*#__PURE__*/
function (_BasePdfManager2) {
  _inherits(NetworkPdfManager, _BasePdfManager2);

function NetworkPdfManager(docId, pdfNetworkStream, args, evaluatorOptions, docBaseUrl) {
    var _this2;

_classCallCheck(this, NetworkPdfManager);

_this2 = _possibleConstructorReturn(this, _getPrototypeOf(NetworkPdfManager).call(this));
    _this2._docId = docId;
    _this2._password = args.password;
    _this2._docBaseUrl = docBaseUrl;
    _this2.msgHandler = args.msgHandler;
    _this2.evaluatorOptions = evaluatorOptions;
    _this2.streamManager = new _chunked_stream.ChunkedStreamManager(pdfNetworkStream, {
      msgHandler: args.msgHandler,
      length: args.length,
      disableAutoFetch: args.disableAutoFetch,
      rangeChunkSize: args.rangeChunkSize
    });
    _this2.pdfDocument = new _document.PDFDocument(_assertThisInitialized(_this2), _this2.streamManager.getStream());
    return _this2;
  }

_createClass(NetworkPdfManager, [{
    key: "ensure",
    value: function () {
      var _ensure3 = _asyncToGenerator(
      /*#__PURE__*/
      _regenerator["default"].mark(function _callee3(obj, prop, args) {
        var value;
        return _regenerator["default"].wrap(function _callee3$(_context3) {
          while (1) {
            switch (_context3.prev = _context3.next) {
              case 0:
                _context3.prev = 0;
                value = obj[prop];

if (!(typeof value === 'function')) {
                  _context3.next = 4;
                  break;
                }

return _context3.abrupt("return", value.apply(obj, args));

case 4:
                return _context3.abrupt("return", value);

case 7:
                _context3.prev = 7;
                _context3.t0 = _context3["catch"](0);

if (_context3.t0 instanceof _core_utils.MissingDataException) {
                  _context3.next = 11;
                  break;
                }

throw _context3.t0;

case 11:
                _context3.next = 13;
                return this.requestRange(_context3.t0.begin, _context3.t0.end);

case 13:
                return _context3.abrupt("return", this.ensure(obj, prop, args));

case 14:
              case "end":
                return _context3.stop();
            }
          }
        }, _callee3, this, [[0, 7]]);
      }));

function ensure(_x7, _x8, _x9) {
        return _ensure3.apply(this, arguments);
      }

return ensure;
    }()
  }, {
    key: "requestRange",
    value: function requestRange(begin, end) {
      return this.streamManager.requestRange(begin, end);
    }
  }, {
    key: "requestLoadedStream",
    value: function requestLoadedStream() {
      this.streamManager.requestAllChunks();
    }
  }, {
    key: "sendProgressiveData",
    value: function sendProgressiveData(chunk) {
      this.streamManager.onReceiveData({
        chunk: chunk
      });
    }
  }, {
    key: "onLoadedStream",
    value: function onLoadedStream() {
      return this.streamManager.onLoadedStream();
    }
  }, {
    key: "terminate",
    value: function terminate(reason) {
      this.streamManager.abort(reason);
    }
  }]);

return NetworkPdfManager;
}(BasePdfManager);

exports.NetworkPdfManager = NetworkPdfManager;

/***/ }),
/* 185 */
/***/ (function(module, exports, __w_pdfjs_require__) {

"use strict";

Object.defineProperty(exports, "__esModule", {
  value: true
});
exports.ChunkedStreamManager = exports.ChunkedStream = void 0;

var _util = __w_pdfjs_require__(5);

var _core_utils = __w_pdfjs_require__(186);

function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }

var ChunkedStream =
/*#__PURE__*/
function () {
  function ChunkedStream(length, chunkSize, manager) {
    _classCallCheck(this, ChunkedStream);

this.bytes = new Uint8Array(length);
    this.start = 0;
    this.pos = 0;
    this.end = length;
    this.chunkSize = chunkSize;
    this.loadedChunks = [];
    this.numChunksLoaded = 0;
    this.numChunks = Math.ceil(length / chunkSize);
    this.manager = manager;
    this.progressiveDataLength = 0;
    this.lastSuccessfulEnsureByteChunk = -1;
  }

_createClass(ChunkedStream, [{
    key: "getMissingChunks",
    value: function getMissingChunks() {
      var chunks = [];

for (var chunk = 0, n = this.numChunks; chunk < n; ++chunk) {
        if (!this.loadedChunks[chunk]) {
          chunks.push(chunk);
        }
      }

return chunks;
    }
  }, {
    key: "getBaseStreams",
    value: function getBaseStreams() {
      return [this];
    }
  }, {
    key: "allChunksLoaded",
    value: function allChunksLoaded() {
      return this.numChunksLoaded === this.numChunks;
    }
  }, {
    key: "onReceiveData",
    value: function onReceiveData(begin, chunk) {
      var chunkSize = this.chunkSize;

if (begin % chunkSize !== 0) {
        throw new Error("Bad begin offset: ".concat(begin));
      }

var end = begin + chunk.byteLength;

if (end % chunkSize !== 0 && end !== this.bytes.length) {
        throw new Error("Bad end offset: ".concat(end));
      }

this.bytes.set(new Uint8Array(chunk), begin);
      var beginChunk = Math.floor(begin / chunkSize);
      var endChunk = Math.floor((end - 1) / chunkSize) + 1;

for (var curChunk = beginChunk; curChunk < endChunk; ++curChunk) {
        if (!this.loadedChunks[curChunk]) {
          this.loadedChunks[curChunk] = true;
          ++this.numChunksLoaded;
        }
      }
    }
  }, {
    key: "onReceiveProgressiveData",
    value: function onReceiveProgressiveData(data) {
      var position = this.progressiveDataLength;
      var beginChunk = Math.floor(position / this.chunkSize);
      this.bytes.set(new Uint8Array(data), position);
      position += data.byteLength;
      this.progressiveDataLength = position;
      var endChunk = position >= this.end ? this.numChunks : Math.floor(position / this.chunkSize);

var chunk = Math.floor(pos / this.chunkSize);

if (chunk === this.lastSuccessfulEnsureByteChunk) {
        return;
      }

if (!this.loadedChunks[chunk]) {
        throw new _core_utils.MissingDataException(pos, pos + 1);
      }

this.lastSuccessfulEnsureByteChunk = chunk;
    }
  }, {
    key: "ensureRange",
    value: function ensureRange(begin, end) {
      if (begin >= end) {
        return;
      }

if (end <= this.progressiveDataLength) {
        return;
      }

var chunkSize = this.chunkSize;
      var beginChunk = Math.floor(begin / chunkSize);
      var endChunk = Math.floor((end - 1) / chunkSize) + 1;

for (var chunk = beginChunk; chunk < endChunk; ++chunk) {
        if (!this.loadedChunks[chunk]) {
          throw new _core_utils.MissingDataException(begin, end);
        }
      }
    }
  }, {
    key: "nextEmptyChunk",
    value: function nextEmptyChunk(beginChunk) {
      var numChunks = this.numChunks;

for (var i = 0; i < numChunks; ++i) {
        var chunk = (beginChunk + i) % numChunks;

if (!this.loadedChunks[chunk]) {
          return chunk;
        }
      }

return null;
    }
  }, {
    key: "hasChunk",
    value: function hasChunk(chunk) {
      return !!this.loadedChunks[chunk];
    }
  }, {
    key: "getByte",
    value: function getByte() {
      var pos = this.pos;

if (pos >= this.end) {
        return -1;
      }

if (pos >= this.progressiveDataLength) {
        this.ensureByte(pos);
      }

return this.bytes[this.pos++];
    }
  }, {
    key: "getUint16",
    value: function getUint16() {
      var b0 = this.getByte();
      var b1 = this.getByte();

if (b0 === -1 || b1 === -1) {
        return -1;
      }

return (b0 << 8) + b1;
    }
  }, {
    key: "getInt32",
    value: function getInt32() {
      var b0 = this.getByte();
      var b1 = this.getByte();
      var b2 = this.getByte();
      var b3 = this.getByte();
      return (b0 << 24) + (b1 << 16) + (b2 << 8) + b3;
    }
  }, {
    key: "getBytes",
    value: function getBytes(length) {
      var forceClamped = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : false;
      var bytes = this.bytes;
      var pos = this.pos;
      var strEnd = this.end;

if (!length) {
        if (strEnd > this.progressiveDataLength) {
          this.ensureRange(pos, strEnd);
        }

var _subarray = bytes.subarray(pos, strEnd);

return forceClamped ? new Uint8ClampedArray(_subarray) : _subarray;
      }

var end = pos + length;

if (end > strEnd) {
        end = strEnd;
      }

if (end > this.progressiveDataLength) {
        this.ensureRange(pos, end);
      }

this.pos = end;
      var subarray = bytes.subarray(pos, end);
      return forceClamped ? new Uint8ClampedArray(subarray) : subarray;
    }
  }, {
    key: "peekByte",
    value: function peekByte() {
      var peekedByte = this.getByte();
      this.pos--;
      return peekedByte;
    }
  }, {
    key: "peekBytes",
    value: function peekBytes(length) {
      var forceClamped = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : false;
      var bytes = this.getBytes(length, forceClamped);
      this.pos -= bytes.length;
      return bytes;
    }
  }, {
    key: "getByteRange",
    value: function getByteRange(begin, end) {
      if (begin < 0) {
        begin = 0;
      }

if (end > this.end) {
        end = this.end;
      }

if (end > this.progressiveDataLength) {
        this.ensureRange(begin, end);
      }

return this.bytes.subarray(begin, end);
    }
  }, {
    key: "skip",
    value: function skip(n) {
      if (!n) {
        n = 1;
      }

this.pos += n;
    }
  }, {
    key: "reset",
    value: function reset() {
      this.pos = this.start;
    }
  }, {
    key: "moveStart",
    value: function moveStart() {
      this.start = this.pos;
    }
  }, {
    key: "makeSubStream",
    value: function makeSubStream(start, length, dict) {
      if (length) {
        if (start + length > this.progressiveDataLength) {
          this.ensureRange(start, start + length);
        }
      } else {
        if (start >= this.progressiveDataLength) {
          this.ensureByte(start);
        }
      }

function ChunkedStreamSubstream() {}

ChunkedStreamSubstream.prototype = Object.create(this);

ChunkedStreamSubstream.prototype.getMissingChunks = function () {
        var chunkSize = this.chunkSize;
        var beginChunk = Math.floor(this.start / chunkSize);
        var endChunk = Math.floor((this.end - 1) / chunkSize) + 1;
        var missingChunks = [];

for (var chunk = beginChunk; chunk < endChunk; ++chunk) {
          if (!this.loadedChunks[chunk]) {
            missingChunks.push(chunk);
          }
        }

return missingChunks;
      };

return ChunkedStream;
}();

exports.ChunkedStream = ChunkedStream;

var ChunkedStreamManager =
/*#__PURE__*/
function () {
  function ChunkedStreamManager(pdfNetworkStream, args) {
    _classCallCheck(this, ChunkedStreamManager);

this.length = args.length;
    this.chunkSize = args.rangeChunkSize;
    this.stream = new ChunkedStream(this.length, this.chunkSize, this);
    this.pdfNetworkStream = pdfNetworkStream;
    this.disableAutoFetch = args.disableAutoFetch;
    this.msgHandler = args.msgHandler;
    this.currRequestId = 0;
    this.chunksNeededByRequest = Object.create(null);
    this.requestsByChunk = Object.create(null);
    this.promisesByRequest = Object.create(null);
    this.progressiveDataLength = 0;
    this.aborted = false;
    this._loadedStreamCapability = (0, _util.createPromiseCapability)();
  }

_createClass(ChunkedStreamManager, [{
    key: "onLoadedStream",
    value: function onLoadedStream() {
      return this._loadedStreamCapability.promise;
    }
  }, {
    key: "sendRequest",
    value: function sendRequest(begin, end) {
      var _this = this;

var rangeReader = this.pdfNetworkStream.getRangeReader(begin, end);

if (!rangeReader.isStreamingSupported) {
        rangeReader.onProgress = this.onProgress.bind(this);
      }

var chunks = [],
          loaded = 0;
      var promise = new Promise(function (resolve, reject) {
        var readChunk = function readChunk(chunk) {
          try {
            if (!chunk.done) {
              var data = chunk.value;
              chunks.push(data);
              loaded += (0, _util.arrayByteLength)(data);

if (rangeReader.isStreamingSupported) {
                _this.onProgress({
                  loaded: loaded
                });
              }

rangeReader.read().then(readChunk, reject);
              return;
            }

var chunkData = (0, _util.arraysToBytes)(chunks);
            chunks = null;
            resolve(chunkData);
          } catch (e) {
            reject(e);
          }
        };

rangeReader.read().then(readChunk, reject);
      });
      promise.then(function (data) {
        if (_this.aborted) {
          return;
        }

_this.onReceiveData({
          chunk: data,
          begin: begin
        });
      });
    }
  }, {
    key: "requestAllChunks",
    value: function requestAllChunks() {
      var missingChunks = this.stream.getMissingChunks();

this._requestChunks(missingChunks);

return this._loadedStreamCapability.promise;
    }
  }, {
    key: "_requestChunks",
    value: function _requestChunks(chunks) {
      var requestId = this.currRequestId++;
      var chunksNeeded = Object.create(null);
      this.chunksNeededByRequest[requestId] = chunksNeeded;
      var _iteratorNormalCompletion = true;
      var _didIteratorError = false;
      var _iteratorError = undefined;

try {
        for (var _iterator = chunks[Symbol.iterator](), _step; !(_iteratorNormalCompletion = (_step = _iterator.next()).done); _iteratorNormalCompletion = true) {
          var _chunk = _step.value;

if (!this.stream.hasChunk(_chunk)) {
            chunksNeeded[_chunk] = true;
          }
        }
      } catch (err) {
        _didIteratorError = true;
        _iteratorError = err;
      } finally {
        try {
          if (!_iteratorNormalCompletion && _iterator["return"] != null) {
            _iterator["return"]();
          }
        } finally {
          if (_didIteratorError) {
            throw _iteratorError;
          }
        }
      }

if ((0, _util.isEmptyObj)(chunksNeeded)) {
        return Promise.resolve();
      }

var capability = (0, _util.createPromiseCapability)();
      this.promisesByRequest[requestId] = capability;
      var chunksToRequest = [];

for (var chunk in chunksNeeded) {
        chunk = chunk | 0;

if (!(chunk in this.requestsByChunk)) {
          this.requestsByChunk[chunk] = [];
          chunksToRequest.push(chunk);
        }

this.requestsByChunk[chunk].push(requestId);
      }

if (!chunksToRequest.length) {
        return capability.promise;
      }

var groupedChunksToRequest = this.groupChunks(chunksToRequest);
      var _iteratorNormalCompletion2 = true;
      var _didIteratorError2 = false;
      var _iteratorError2 = undefined;

try {
        for (var _iterator2 = groupedChunksToRequest[Symbol.iterator](), _step2; !(_iteratorNormalCompletion2 = (_step2 = _iterator2.next()).done); _iteratorNormalCompletion2 = true) {
          var groupedChunk = _step2.value;
          var begin = groupedChunk.beginChunk * this.chunkSize;
          var end = Math.min(groupedChunk.endChunk * this.chunkSize, this.length);
          this.sendRequest(begin, end);
        }
      } catch (err) {
        _didIteratorError2 = true;
        _iteratorError2 = err;
      } finally {
        try {
          if (!_iteratorNormalCompletion2 && _iterator2["return"] != null) {
            _iterator2["return"]();
          }
        } finally {
          if (_didIteratorError2) {
            throw _iteratorError2;
          }
        }
      }

return capability.promise;
    }
  }, {
    key: "getStream",
    value: function getStream() {
      return this.stream;
    }
  }, {
    key: "requestRange",
    value: function requestRange(begin, end) {
      end = Math.min(end, this.length);
      var beginChunk = this.getBeginChunk(begin);
      var endChunk = this.getEndChunk(end);
      var chunks = [];

for (var chunk = beginChunk; chunk < endChunk; ++chunk) {
        chunks.push(chunk);
      }

return this._requestChunks(chunks);
    }
  }, {
    key: "requestRanges",
    value: function requestRanges() {
      var ranges = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : [];
      var chunksToRequest = [];
      var _iteratorNormalCompletion3 = true;
      var _didIteratorError3 = false;
      var _iteratorError3 = undefined;

try {
        for (var _iterator3 = ranges[Symbol.iterator](), _step3; !(_iteratorNormalCompletion3 = (_step3 = _iterator3.next()).done); _iteratorNormalCompletion3 = true) {
          var range = _step3.value;
          var beginChunk = this.getBeginChunk(range.begin);
          var endChunk = this.getEndChunk(range.end);

for (var chunk = beginChunk; chunk < endChunk; ++chunk) {
            if (!chunksToRequest.includes(chunk)) {
              chunksToRequest.push(chunk);
            }
          }
        }
      } catch (err) {
        _didIteratorError3 = true;
        _iteratorError3 = err;
      } finally {
        try {
          if (!_iteratorNormalCompletion3 && _iterator3["return"] != null) {
            _iterator3["return"]();
          }
        } finally {
          if (_didIteratorError3) {
            throw _iteratorError3;
          }
        }
      }

chunksToRequest.sort(function (a, b) {
        return a - b;
      });
      return this._requestChunks(chunksToRequest);
    }
  }, {
    key: "groupChunks",
    value: function groupChunks(chunks) {
      var groupedChunks = [];
      var beginChunk = -1;
      var prevChunk = -1;

for (var i = 0, ii = chunks.length; i < ii; ++i) {
        var chunk = chunks[i];

if (beginChunk < 0) {
          beginChunk = chunk;
        }

if (prevChunk >= 0 && prevChunk + 1 !== chunk) {
          groupedChunks.push({
            beginChunk: beginChunk,
            endChunk: prevChunk + 1
          });
          beginChunk = chunk;
        }

if (i + 1 === chunks.length) {
          groupedChunks.push({
            beginChunk: beginChunk,
            endChunk: chunk + 1
          });
        }

prevChunk = chunk;
      }

return groupedChunks;
    }
  }, {
    key: "onProgress",
    value: function onProgress(args) {
      this.msgHandler.send('DocProgress', {
        loaded: this.stream.numChunksLoaded * this.chunkSize + args.loaded,
        total: this.length
      });
    }
  }, {
    key: "onReceiveData",
    value: function onReceiveData(args) {
      var chunk = args.chunk;
      var isProgressive = args.begin === undefined;
      var begin = isProgressive ? this.progressiveDataLength : args.begin;
      var end = begin + chunk.byteLength;
      var beginChunk = Math.floor(begin / this.chunkSize);
      var endChunk = end < this.length ? Math.floor(end / this.chunkSize) : Math.ceil(end / this.chunkSize);

if (isProgressive) {
        this.stream.onReceiveProgressiveData(chunk);
        this.progressiveDataLength = end;
      } else {
        this.stream.onReceiveData(begin, chunk);
      }

if (this.stream.allChunksLoaded()) {
        this._loadedStreamCapability.resolve(this.stream);
      }

var loadedRequests = [];

for (var _chunk2 = beginChunk; _chunk2 < endChunk; ++_chunk2) {
        var requestIds = this.requestsByChunk[_chunk2] || [];
        delete this.requestsByChunk[_chunk2];
        var _iteratorNormalCompletion4 = true;
        var _didIteratorError4 = false;
        var _iteratorError4 = undefined;

try {
          for (var _iterator4 = requestIds[Symbol.iterator](), _step4; !(_iteratorNormalCompletion4 = (_step4 = _iterator4.next()).done); _iteratorNormalCompletion4 = true) {
            var requestId = _step4.value;
            var chunksNeeded = this.chunksNeededByRequest[requestId];

if (_chunk2 in chunksNeeded) {
              delete chunksNeeded[_chunk2];
            }

if (!(0, _util.isEmptyObj)(chunksNeeded)) {
              continue;
            }

loadedRequests.push(requestId);
          }
        } catch (err) {
          _didIteratorError4 = true;
          _iteratorError4 = err;
        } finally {
          try {
            if (!_iteratorNormalCompletion4 && _iterator4["return"] != null) {
              _iterator4["return"]();
            }
          } finally {
            if (_didIteratorError4) {
              throw _iteratorError4;
            }
          }
        }
      }

if (!this.disableAutoFetch && (0, _util.isEmptyObj)(this.requestsByChunk)) {
        var nextEmptyChunk;

if (this.stream.numChunksLoaded === 1) {
          var lastChunk = this.stream.numChunks - 1;

if (!this.stream.hasChunk(lastChunk)) {
            nextEmptyChunk = lastChunk;
          }
        } else {
          nextEmptyChunk = this.stream.nextEmptyChunk(endChunk);
        }

if (Number.isInteger(nextEmptyChunk)) {
          this._requestChunks([nextEmptyChunk]);
        }
      }

for (var _i = 0, _loadedRequests = loadedRequests; _i < _loadedRequests.length; _i++) {
        var _requestId = _loadedRequests[_i];
        var capability = this.promisesByRequest[_requestId];
        delete this.promisesByRequest[_requestId];
        capability.resolve();
      }

this.msgHandler.send('DocProgress', {
        loaded: this.stream.numChunksLoaded * this.chunkSize,
        total: this.length
      });
    }
  }, {
    key: "onError",
    value: function onError(err) {
      this._loadedStreamCapability.reject(err);
    }
  }, {
    key: "getBeginChunk",
    value: function getBeginChunk(begin) {
      return Math.floor(begin / this.chunkSize);
    }
  }, {
    key: "getEndChunk",
    value: function getEndChunk(end) {
      return Math.floor((end - 1) / this.chunkSize) + 1;
    }
  }, {
    key: "abort",
    value: function abort(reason) {
      this.aborted = true;

if (this.pdfNetworkStream) {
        this.pdfNetworkStream.cancelAllRequests(reason);
      }

for (var requestId in this.promisesByRequest) {
        this.promisesByRequest[requestId].reject(reason);
      }
    }
  }]);

return ChunkedStreamManager;
}();

exports.ChunkedStreamManager = ChunkedStreamManager;

/***/ }),
/* 186 */
/***/ (function(module, exports, __w_pdfjs_require__) {

"use strict";

Object.defineProperty(exports, "__esModule", {
  value: true
});
exports.getLookupTableFactory = getLookupTableFactory;
exports.getInheritableProperty = getInheritableProperty;
exports.toRomanNumerals = toRomanNumerals;
exports.XRefParseException = exports.XRefEntryException = exports.MissingDataException = void 0;

var _util = __w_pdfjs_require__(5);

function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }

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 _setPrototypeOf(o, p) { _setPrototypeOf = Object.setPrototypeOf || function _setPrototypeOf(o, p) { o.__proto__ = p; return o; }; return _setPrototypeOf(o, p); }

function getLookupTableFactory(initializer) {
  var lookup;
  return function () {
    if (initializer) {
      lookup = Object.create(null);
      initializer(lookup);
      initializer = null;
    }

return lookup;
  };
}

var MissingDataException =
/*#__PURE__*/
function (_BaseException) {
  _inherits(MissingDataException, _BaseException);

function MissingDataException(begin, end) {
    var _this;

_classCallCheck(this, MissingDataException);

_this = _possibleConstructorReturn(this, _getPrototypeOf(MissingDataException).call(this, "Missing data [".concat(begin, ", ").concat(end, ")")));
    _this.begin = begin;
    _this.end = end;
    return _this;
  }

return MissingDataException;
}(_util.BaseException);

exports.MissingDataException = MissingDataException;

var XRefEntryException =
/*#__PURE__*/
function (_BaseException2) {
  _inherits(XRefEntryException, _BaseException2);

function XRefEntryException() {
    _classCallCheck(this, XRefEntryException);

return _possibleConstructorReturn(this, _getPrototypeOf(XRefEntryException).apply(this, arguments));
  }

return XRefEntryException;
}(_util.BaseException);

exports.XRefEntryException = XRefEntryException;

var XRefParseException =
/*#__PURE__*/
function (_BaseException3) {
  _inherits(XRefParseException, _BaseException3);

function XRefParseException() {
    _classCallCheck(this, XRefParseException);

return _possibleConstructorReturn(this, _getPrototypeOf(XRefParseException).apply(this, arguments));
  }

return XRefParseException;
}(_util.BaseException);

exports.XRefParseException = XRefParseException;

function getInheritableProperty(_ref) {
  var dict = _ref.dict,
      key = _ref.key,
      _ref$getArray = _ref.getArray,
      getArray = _ref$getArray === void 0 ? false : _ref$getArray,
      _ref$stopWhenFound = _ref.stopWhenFound,
      stopWhenFound = _ref$stopWhenFound === void 0 ? true : _ref$stopWhenFound;
  var LOOP_LIMIT = 100;
  var loopCount = 0;
  var values;

while (dict) {
    var value = getArray ? dict.getArray(key) : dict.get(key);

if (value !== undefined) {
      if (stopWhenFound) {
        return value;
      }

if (!values) {
        values = [];
      }

values.push(value);
    }

if (++loopCount > LOOP_LIMIT) {
      (0, _util.warn)("getInheritableProperty: maximum loop count exceeded for \"".concat(key, "\""));
      break;
    }

dict = dict.get('Parent');
  }

return values;
}

var ROMAN_NUMBER_MAP = ['', 'C', 'CC', 'CCC', 'CD', 'D', 'DC', 'DCC', 'DCCC', 'CM', '', 'X', 'XX', 'XXX', 'XL', 'L', 'LX', 'LXX', 'LXXX', 'XC', '', 'I', 'II', 'III', 'IV', 'V', 'VI', 'VII', 'VIII', 'IX'];

function toRomanNumerals(number) {
  var lowerCase = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : false;
  (0, _util.assert)(Number.isInteger(number) && number > 0, 'The number should be a positive integer.');
  var pos,
      romanBuf = [];

while (number >= 1000) {
    number -= 1000;
    romanBuf.push('M');
  }

pos = number / 100 | 0;
  number %= 100;
  romanBuf.push(ROMAN_NUMBER_MAP[pos]);
  pos = number / 10 | 0;
  number %= 10;
  romanBuf.push(ROMAN_NUMBER_MAP[10 + pos]);
  romanBuf.push(ROMAN_NUMBER_MAP[20 + number]);
  var romanStr = romanBuf.join('');
  return lowerCase ? romanStr.toLowerCase() : romanStr;
}

/***/ }),
/* 187 */
/***/ (function(module, exports, __w_pdfjs_require__) {

"use strict";

Object.defineProperty(exports, "__esModule", {
  value: true
});
exports.PDFDocument = exports.Page = void 0;

var _util = __w_pdfjs_require__(5);

var _obj = __w_pdfjs_require__(188);

var _primitives = __w_pdfjs_require__(183);

var _core_utils = __w_pdfjs_require__(186);

var _stream2 = __w_pdfjs_require__(190);

var _annotation = __w_pdfjs_require__(202);

var _crypto = __w_pdfjs_require__(200);

var _parser = __w_pdfjs_require__(189);

var _operator_list = __w_pdfjs_require__(203);

var _evaluator = __w_pdfjs_require__(204);

var _function = __w_pdfjs_require__(218);

function _slicedToArray(arr, i) { return _arrayWithHoles(arr) || _iterableToArrayLimit(arr, i) || _nonIterableRest(); }

function _nonIterableRest() { throw new TypeError("Invalid attempt to destructure non-iterable instance"); }

function _arrayWithHoles(arr) { if (Array.isArray(arr)) return arr; }

function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }

var DEFAULT_USER_UNIT = 1.0;
var LETTER_SIZE_MEDIABOX = [0, 0, 612, 792];

function isAnnotationRenderable(annotation, intent) {
  return intent === 'display' && annotation.viewable || intent === 'print' && annotation.printable;
}

var Page =
/*#__PURE__*/
function () {
  function Page(_ref) {
    var pdfManager = _ref.pdfManager,
        xref = _ref.xref,
        pageIndex = _ref.pageIndex,
        pageDict = _ref.pageDict,
        ref = _ref.ref,
        fontCache = _ref.fontCache,
        builtInCMapCache = _ref.builtInCMapCache,
        pdfFunctionFactory = _ref.pdfFunctionFactory;

_classCallCheck(this, Page);

this.pdfManager = pdfManager;
    this.pageIndex = pageIndex;
    this.pageDict = pageDict;
    this.xref = xref;
    this.ref = ref;
    this.fontCache = fontCache;
    this.builtInCMapCache = builtInCMapCache;
    this.pdfFunctionFactory = pdfFunctionFactory;
    this.evaluatorOptions = pdfManager.evaluatorOptions;
    this.resourcesPromise = null;
    var idCounters = {
      obj: 0
    };
    this.idFactory = {
      createObjId: function createObjId() {
        return "p".concat(pageIndex, "_").concat(++idCounters.obj);
      },
      getDocId: function getDocId() {
        return "g_".concat(pdfManager.docId);
      }
    };
  }

_createClass(Page, [{
    key: "_getInheritableProperty",
    value: function _getInheritableProperty(key) {
      var getArray = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : false;
      var value = (0, _core_utils.getInheritableProperty)({
        dict: this.pageDict,
        key: key,
        getArray: getArray,
        stopWhenFound: false
      });

if (!Array.isArray(value)) {
        return value;
      }

if (value.length === 1 || !(0, _primitives.isDict)(value[0])) {
        return value[0];
      }

return _primitives.Dict.merge(this.xref, value);
    }
  }, {
    key: "_getBoundingBox",
    value: function _getBoundingBox(name) {
      var box = this._getInheritableProperty(name, true);

if (Array.isArray(box) && box.length === 4) {
        if (box[2] - box[0] !== 0 && box[3] - box[1] !== 0) {
          return box;
        }

(0, _util.warn)("Empty /".concat(name, " entry."));
      }

return null;
    }
  }, {
    key: "getContentStream",
    value: function getContentStream() {
      var content = this.content;
      var stream;

if (Array.isArray(content)) {
        var xref = this.xref;
        var streams = [];
        var _iteratorNormalCompletion = true;
        var _didIteratorError = false;
        var _iteratorError = undefined;

try {
          for (var _iterator = content[Symbol.iterator](), _step; !(_iteratorNormalCompletion = (_step = _iterator.next()).done); _iteratorNormalCompletion = true) {
            var _stream = _step.value;
            streams.push(xref.fetchIfRef(_stream));
          }
        } catch (err) {
          _didIteratorError = true;
          _iteratorError = err;
        } finally {
          try {
            if (!_iteratorNormalCompletion && _iterator["return"] != null) {
              _iterator["return"]();
            }
          } finally {
            if (_didIteratorError) {
              throw _iteratorError;
            }
          }
        }

stream = new _stream2.StreamsSequenceStream(streams);
      } else if ((0, _primitives.isStream)(content)) {
        stream = content;
      } else {
        stream = new _stream2.NullStream();
      }

return stream;
    }
  }, {
    key: "loadResources",
    value: function loadResources(keys) {
      var _this = this;

if (!this.resourcesPromise) {
        this.resourcesPromise = this.pdfManager.ensure(this, 'resources');
      }

return this.resourcesPromise.then(function () {
        var objectLoader = new _obj.ObjectLoader(_this.resources, keys, _this.xref);
        return objectLoader.load();
      });
    }
  }, {
    key: "getOperatorList",
    value: function getOperatorList(_ref2) {
      var _this2 = this;

var handler = _ref2.handler,
          sink = _ref2.sink,
          task = _ref2.task,
          intent = _ref2.intent,
          renderInteractiveForms = _ref2.renderInteractiveForms;
      var contentStreamPromise = this.pdfManager.ensure(this, 'getContentStream');
      var resourcesPromise = this.loadResources(['ExtGState', 'ColorSpace', 'Pattern', 'Shading', 'XObject', 'Font']);
      var partialEvaluator = new _evaluator.PartialEvaluator({
        xref: this.xref,
        handler: handler,
        pageIndex: this.pageIndex,
        idFactory: this.idFactory,
        fontCache: this.fontCache,
        builtInCMapCache: this.builtInCMapCache,
        options: this.evaluatorOptions,
        pdfFunctionFactory: this.pdfFunctionFactory
      });
      var dataPromises = Promise.all([contentStreamPromise, resourcesPromise]);
      var pageListPromise = dataPromises.then(function (_ref3) {
        var _ref4 = _slicedToArray(_ref3, 1),
            contentStream = _ref4[0];

if (annotations.length === 0) {
          pageOpList.flush(true);
          return {
            length: pageOpList.totalLength
          };
        }

var opListPromises = [];
        var _iteratorNormalCompletion2 = true;
        var _didIteratorError2 = false;
        var _iteratorError2 = undefined;

try {
          for (var _iterator2 = annotations[Symbol.iterator](), _step2; !(_iteratorNormalCompletion2 = (_step2 = _iterator2.next()).done); _iteratorNormalCompletion2 = true) {
            var annotation = _step2.value;

if (isAnnotationRenderable(annotation, intent)) {
              opListPromises.push(annotation.getOperatorList(partialEvaluator, task, renderInteractiveForms));
            }
          }
        } catch (err) {
          _didIteratorError2 = true;
          _iteratorError2 = err;
        } finally {
          try {
            if (!_iteratorNormalCompletion2 && _iterator2["return"] != null) {
              _iterator2["return"]();
            }
          } finally {
            if (_didIteratorError2) {
              throw _iteratorError2;
            }
          }
        }

return Promise.all(opListPromises).then(function (opLists) {
          pageOpList.addOp(_util.OPS.beginAnnotations, []);
          var _iteratorNormalCompletion3 = true;
          var _didIteratorError3 = false;
          var _iteratorError3 = undefined;

try {
            for (var _iterator3 = opLists[Symbol.iterator](), _step3; !(_iteratorNormalCompletion3 = (_step3 = _iterator3.next()).done); _iteratorNormalCompletion3 = true) {
              var opList = _step3.value;
              pageOpList.addOpList(opList);
            }
          } catch (err) {
            _didIteratorError3 = true;
            _iteratorError3 = err;
          } finally {
            try {
              if (!_iteratorNormalCompletion3 && _iterator3["return"] != null) {
                _iterator3["return"]();
              }
            } finally {
              if (_didIteratorError3) {
                throw _iteratorError3;
              }
            }
          }

pageOpList.addOp(_util.OPS.endAnnotations, []);
          pageOpList.flush(true);
          return {
            length: pageOpList.totalLength
          };
        });
      });
    }
  }, {
    key: "extractTextContent",
    value: function extractTextContent(_ref7) {
      var _this3 = this;

var handler = _ref7.handler,
          task = _ref7.task,
          normalizeWhitespace = _ref7.normalizeWhitespace,
          sink = _ref7.sink,
          combineTextItems = _ref7.combineTextItems;
      var contentStreamPromise = this.pdfManager.ensure(this, 'getContentStream');
      var resourcesPromise = this.loadResources(['ExtGState', 'XObject', 'Font']);
      var dataPromises = Promise.all([contentStreamPromise, resourcesPromise]);
      return dataPromises.then(function (_ref8) {
        var _ref9 = _slicedToArray(_ref8, 1),
            contentStream = _ref9[0];

for (var i = 0, ii = annotations.length; i < ii; i++) {
          if (!intent || isAnnotationRenderable(annotations[i], intent)) {
            annotationsData.push(annotations[i].data);
          }
        }

return annotationsData;
      });
    }
  }, {
    key: "content",
    get: function get() {
      return this.pageDict.get('Contents');
    }
  }, {
    key: "resources",
    get: function get() {
      return (0, _util.shadow)(this, 'resources', this._getInheritableProperty('Resources') || _primitives.Dict.empty);
    }
  }, {
    key: "mediaBox",
    get: function get() {
      return (0, _util.shadow)(this, 'mediaBox', this._getBoundingBox('MediaBox') || LETTER_SIZE_MEDIABOX);
    }
  }, {
    key: "cropBox",
    get: function get() {
      return (0, _util.shadow)(this, 'cropBox', this._getBoundingBox('CropBox') || this.mediaBox);
    }
  }, {
    key: "userUnit",
    get: function get() {
      var obj = this.pageDict.get('UserUnit');

if (!(0, _util.isNum)(obj) || obj <= 0) {
        obj = DEFAULT_USER_UNIT;
      }

return (0, _util.shadow)(this, 'userUnit', obj);
    }
  }, {
    key: "view",
    get: function get() {
      var cropBox = this.cropBox,
          mediaBox = this.mediaBox;
      var view;

if (cropBox === mediaBox || (0, _util.isArrayEqual)(cropBox, mediaBox)) {
        view = mediaBox;
      } else {
        var box = _util.Util.intersect(cropBox, mediaBox);

if (box && box[2] - box[0] !== 0 && box[3] - box[1] !== 0) {
          view = box;
        } else {
          (0, _util.warn)('Empty /CropBox and /MediaBox intersection.');
        }
      }

return (0, _util.shadow)(this, 'view', view || mediaBox);
    }
  }, {
    key: "rotate",
    get: function get() {
      var rotate = this._getInheritableProperty('Rotate') || 0;

if (rotate % 90 !== 0) {
        rotate = 0;
      } else if (rotate >= 360) {
        rotate = rotate % 360;
      } else if (rotate < 0) {
        rotate = (rotate % 360 + 360) % 360;
      }

return (0, _util.shadow)(this, 'rotate', rotate);
    }
  }, {
    key: "annotations",
    get: function get() {
      return (0, _util.shadow)(this, 'annotations', this._getInheritableProperty('Annots') || []);
    }
  }, {
    key: "_parsedAnnotations",
    get: function get() {
      var _this4 = this;

var parsedAnnotations = this.pdfManager.ensure(this, 'annotations').then(function () {
        var annotationRefs = _this4.annotations;
        var annotationPromises = [];

for (var i = 0, ii = annotationRefs.length; i < ii; i++) {
          annotationPromises.push(_annotation.AnnotationFactory.create(_this4.xref, annotationRefs[i], _this4.pdfManager, _this4.idFactory));
        }

return Promise.all(annotationPromises).then(function (annotations) {
          return annotations.filter(function isDefined(annotation) {
            return !!annotation;
          });
        }, function (reason) {
          (0, _util.warn)("_parsedAnnotations: \"".concat(reason, "\"."));
          return [];
        });
      });
      return (0, _util.shadow)(this, '_parsedAnnotations', parsedAnnotations);
    }
  }]);

return Page;
}();

exports.Page = Page;
var FINGERPRINT_FIRST_BYTES = 1024;
var EMPTY_FINGERPRINT = '\x00\x00\x00\x00\x00\x00\x00' + '\x00\x00\x00\x00\x00\x00\x00\x00\x00';

function find(stream, needle, limit) {
  var backwards = arguments.length > 3 && arguments[3] !== undefined ? arguments[3] : false;
  (0, _util.assert)(limit > 0, 'The "limit" must be a positive integer.');
  var str = (0, _util.bytesToString)(stream.peekBytes(limit));
  var index = backwards ? str.lastIndexOf(needle) : str.indexOf(needle);

if (index === -1) {
    return false;
  }

stream.pos += index;
  return true;
}

var PDFDocument =
/*#__PURE__*/
function () {
  function PDFDocument(pdfManager, arg) {
    _classCallCheck(this, PDFDocument);

var stream;

if ((0, _primitives.isStream)(arg)) {
      stream = arg;
    } else if ((0, _util.isArrayBuffer)(arg)) {
      stream = new _stream2.Stream(arg);
    } else {
      throw new Error('PDFDocument: Unknown argument type');
    }

if (stream.length <= 0) {
      throw new Error('PDFDocument: Stream must have data');
    }

this.pdfManager = pdfManager;
    this.stream = stream;
    this.xref = new _obj.XRef(stream, pdfManager);
    this.pdfFunctionFactory = new _function.PDFFunctionFactory({
      xref: this.xref,
      isEvalSupported: pdfManager.evaluatorOptions.isEvalSupported
    });
    this._pagePromises = [];
  }

_createClass(PDFDocument, [{
    key: "parse",
    value: function parse(recoveryMode) {
      this.setup(recoveryMode);
      var version = this.catalog.catDict.get('Version');

if ((0, _primitives.isName)(version)) {
        this.pdfFormatVersion = version.name;
      }

try {
        this.acroForm = this.catalog.catDict.get('AcroForm');

if (this.acroForm) {
          this.xfa = this.acroForm.get('XFA');
          var fields = this.acroForm.get('Fields');

if ((!Array.isArray(fields) || fields.length === 0) && !this.xfa) {
            this.acroForm = null;
          }
        }
      } catch (ex) {
        if (ex instanceof _core_utils.MissingDataException) {
          throw ex;
        }

(0, _util.info)('Cannot fetch AcroForm entry; assuming no AcroForms are present');
        this.acroForm = null;
      }

try {
        var collection = this.catalog.catDict.get('Collection');

if ((0, _primitives.isDict)(collection) && collection.getKeys().length > 0) {
          this.collection = collection;
        }
      } catch (ex) {
        if (ex instanceof _core_utils.MissingDataException) {
          throw ex;
        }

(0, _util.info)('Cannot fetch Collection dictionary.');
      }
    }
  }, {
    key: "checkHeader",
    value: function checkHeader() {
      var stream = this.stream;
      stream.reset();

if (!find(stream, '%PDF-', 1024)) {
        return;
      }

stream.moveStart();
      var MAX_PDF_VERSION_LENGTH = 12;
      var version = '',
          ch;

while ((ch = stream.getByte()) > 0x20) {
        if (version.length >= MAX_PDF_VERSION_LENGTH) {
          break;
        }

version += String.fromCharCode(ch);
      }

if (!this.pdfFormatVersion) {
        this.pdfFormatVersion = version.substring(5);
      }
    }
  }, {
    key: "parseStartXRef",
    value: function parseStartXRef() {
      this.xref.setStartXRef(this.startXRef);
    }
  }, {
    key: "setup",
    value: function setup(recoveryMode) {
      this.xref.parse(recoveryMode);
      this.catalog = new _obj.Catalog(this.pdfManager, this.xref);
    }
  }, {
    key: "_getLinearizationPage",
    value: function _getLinearizationPage(pageIndex) {
      var catalog = this.catalog,
          linearization = this.linearization;
      (0, _util.assert)(linearization && linearization.pageFirst === pageIndex);

var ref = _primitives.Ref.get(linearization.objectNumberFirst, 0);

return this.xref.fetchAsync(ref).then(function (obj) {
        if ((0, _primitives.isDict)(obj, 'Page') || (0, _primitives.isDict)(obj) && !obj.has('Type') && obj.has('Contents')) {
          if (ref && !catalog.pageKidsCountCache.has(ref)) {
            catalog.pageKidsCountCache.put(ref, 1);
          }

return [obj, ref];
        }

throw new _util.FormatError('The Linearization dictionary doesn\'t point ' + 'to a valid Page dictionary.');
      })["catch"](function (reason) {
        (0, _util.info)(reason);
        return catalog.getPageDict(pageIndex);
      });
    }
  }, {
    key: "getPage",
    value: function getPage(pageIndex) {
      var _this5 = this;

if (this._pagePromises[pageIndex] !== undefined) {
        return this._pagePromises[pageIndex];
      }

var catalog = this.catalog,
          linearization = this.linearization;
      var promise = linearization && linearization.pageFirst === pageIndex ? this._getLinearizationPage(pageIndex) : catalog.getPageDict(pageIndex);
      return this._pagePromises[pageIndex] = promise.then(function (_ref10) {
        var _ref11 = _slicedToArray(_ref10, 2),
            pageDict = _ref11[0],
            ref = _ref11[1];

return new Page({
          pdfManager: _this5.pdfManager,
          xref: _this5.xref,
          pageIndex: pageIndex,
          pageDict: pageDict,
          ref: ref,
          fontCache: catalog.fontCache,
          builtInCMapCache: catalog.builtInCMapCache,
          pdfFunctionFactory: _this5.pdfFunctionFactory
        });
      });
    }
  }, {
    key: "checkFirstPage",
    value: function checkFirstPage() {
      var _this6 = this;

return this.getPage(0)["catch"](function (reason) {
        if (reason instanceof _core_utils.XRefEntryException) {
          _this6._pagePromises.length = 0;

_this6.cleanup();

throw new _core_utils.XRefParseException();
        }
      });
    }
  }, {
    key: "fontFallback",
    value: function fontFallback(id, handler) {
      return this.catalog.fontFallback(id, handler);
    }
  }, {
    key: "cleanup",
    value: function cleanup() {
      return this.catalog.cleanup();
    }
  }, {
    key: "linearization",
    get: function get() {
      var linearization = null;

try {
        linearization = _parser.Linearization.create(this.stream);
      } catch (err) {
        if (err instanceof _core_utils.MissingDataException) {
          throw err;
        }

(0, _util.info)(err);
      }

return (0, _util.shadow)(this, 'linearization', linearization);
    }
  }, {
    key: "startXRef",
    get: function get() {
      var stream = this.stream;
      var startXRef = 0;

if (this.linearization) {
        stream.reset();

if (find(stream, 'endobj', 1024)) {
          startXRef = stream.pos + 6;
        }
      } else {
        var step = 1024;
        var startXRefLength = 'startxref'.length;
        var found = false,
            pos = stream.end;

while (!found && pos > 0) {
          pos -= step - startXRefLength;

if (pos < 0) {
            pos = 0;
          }

stream.pos = pos;
          found = find(stream, 'startxref', step, true);
        }

if (found) {
          stream.skip(9);
          var ch;

do {
            ch = stream.getByte();
          } while ((0, _util.isSpace)(ch));

var str = '';

while (ch >= 0x20 && ch <= 0x39) {
            str += String.fromCharCode(ch);
            ch = stream.getByte();
          }

startXRef = parseInt(str, 10);

if (isNaN(startXRef)) {
            startXRef = 0;
          }
        }
      }

return (0, _util.shadow)(this, 'startXRef', startXRef);
    }
  }, {
    key: "numPages",
    get: function get() {
      var linearization = this.linearization;
      var num = linearization ? linearization.numPages : this.catalog.numPages;
      return (0, _util.shadow)(this, 'numPages', num);
    }
  }, {
    key: "documentInfo",
    get: function get() {
      var DocumentInfoValidators = {
        Title: _util.isString,
        Author: _util.isString,
        Subject: _util.isString,
        Keywords: _util.isString,
        Creator: _util.isString,
        Producer: _util.isString,
        CreationDate: _util.isString,
        ModDate: _util.isString,
        Trapped: _primitives.isName
      };
      var docInfo = {
        PDFFormatVersion: this.pdfFormatVersion,
        IsLinearized: !!this.linearization,
        IsAcroFormPresent: !!this.acroForm,
        IsXFAPresent: !!this.xfa,
        IsCollectionPresent: !!this.collection
      };
      var infoDict;

try {
        infoDict = this.xref.trailer.get('Info');
      } catch (err) {
        if (err instanceof _core_utils.MissingDataException) {
          throw err;
        }

(0, _util.info)('The document information dictionary is invalid.');
      }

if ((0, _primitives.isDict)(infoDict)) {
        var _iteratorNormalCompletion4 = true;
        var _didIteratorError4 = false;
        var _iteratorError4 = undefined;

try {
          for (var _iterator4 = infoDict.getKeys()[Symbol.iterator](), _step4; !(_iteratorNormalCompletion4 = (_step4 = _iterator4.next()).done); _iteratorNormalCompletion4 = true) {
            var key = _step4.value;
            var value = infoDict.get(key);

if (DocumentInfoValidators[key]) {
              if (DocumentInfoValidators[key](value)) {
                docInfo[key] = typeof value !== 'string' ? value : (0, _util.stringToPDFString)(value);
              } else {
                (0, _util.info)("Bad value in document info for \"".concat(key, "\"."));
              }
            } else if (typeof key === 'string') {
              var customValue = void 0;

if ((0, _util.isString)(value)) {
                customValue = (0, _util.stringToPDFString)(value);
              } else if ((0, _primitives.isName)(value) || (0, _util.isNum)(value) || (0, _util.isBool)(value)) {
                customValue = value;
              } else {
                (0, _util.info)("Unsupported value in document info for (custom) \"".concat(key, "\"."));
                continue;
              }

if (!docInfo['Custom']) {
                docInfo['Custom'] = Object.create(null);
              }

docInfo['Custom'][key] = customValue;
            }
          }
        } catch (err) {
          _didIteratorError4 = true;
          _iteratorError4 = err;
        } finally {
          try {
            if (!_iteratorNormalCompletion4 && _iterator4["return"] != null) {
              _iterator4["return"]();
            }
          } finally {
            if (_didIteratorError4) {
              throw _iteratorError4;
            }
          }
        }
      }

return (0, _util.shadow)(this, 'documentInfo', docInfo);
    }
  }, {
    key: "fingerprint",
    get: function get() {
      var hash;
      var idArray = this.xref.trailer.get('ID');

if (Array.isArray(idArray) && idArray[0] && (0, _util.isString)(idArray[0]) && idArray[0] !== EMPTY_FINGERPRINT) {
        hash = (0, _util.stringToBytes)(idArray[0]);
      } else {
        hash = (0, _crypto.calculateMD5)(this.stream.getByteRange(0, FINGERPRINT_FIRST_BYTES), 0, FINGERPRINT_FIRST_BYTES);
      }

var fingerprintBuf = [];

for (var i = 0, ii = hash.length; i < ii; i++) {
        var hex = hash[i].toString(16);
        fingerprintBuf.push(hex.padStart(2, '0'));
      }

return (0, _util.shadow)(this, 'fingerprint', fingerprintBuf.join(''));
    }
  }]);

return PDFDocument;
}();

exports.PDFDocument = PDFDocument;

/***/ }),
/* 188 */
/***/ (function(module, exports, __w_pdfjs_require__) {

"use strict";

Object.defineProperty(exports, "__esModule", {
  value: true
});
exports.FileSpec = exports.XRef = exports.ObjectLoader = exports.Catalog = void 0;

var _regenerator = _interopRequireDefault(__w_pdfjs_require__(2));

var _util = __w_pdfjs_require__(5);

var _primitives = __w_pdfjs_require__(183);

var _parser = __w_pdfjs_require__(189);

var _core_utils = __w_pdfjs_require__(186);

var _chunked_stream = __w_pdfjs_require__(185);

var _crypto = __w_pdfjs_require__(200);

var _colorspace = __w_pdfjs_require__(201);